· Nacho Coll · Guides  · 11 min de citit

Tokenuri de încărcare IPFS: încărcări securizate din partea clientului fără expunerea cheilor API

Aflați cum tokenurile de încărcare semnate vă permit să încărcați în siguranță pe IPFS din browsere și aplicații mobile fără a expune cheia API.

Aflați cum tokenurile de încărcare semnate vă permit să încărcați în siguranță pe IPFS din browsere și aplicații mobile fără a expune cheia API.

Construirea aplicațiilor web moderne necesită adesea încărcarea fișierelor direct din browserele utilizatorilor către stocarea în cloud. Cu toate acestea, când vine vorba de securitatea încărcărilor IPFS, dezvoltatorii se confruntă cu o dilemă dificilă: cum permiți încărcări din partea clientului fără a expune cheile API prețioase la potențiale abuzuri?

Majoritatea serviciilor de pinning IPFS vă forțează să alegeți între opțiuni neplăcute: fie gestionați toate încărcările pe partea serverului (creând blocaje și complexitate), fie încorporați cheia API în codul clientului (un coșmar de securitate). IPFS.NINJA rezolvă această problemă cu o funcționalitate unică pe care niciun alt serviciu de pinning nu o oferă: tokenuri de încărcare semnate.

IPFS Ninja

Problema cu cheile API IPFS tradiționale

Când construiți aplicații pe partea clientului care trebuie să încarce pe IPFS, dezvoltatorii întâmpină de obicei mai multe provocări de securitate:

Riscul expunerii cheii API

Încorporarea cheilor API direct în JavaScript-ul browserului înseamnă că oricine poate vizualiza codul sursă și extrage acreditările dvs. Aceasta ar putea duce la:

  • Încărcări neautorizate care consumă cota de stocare
  • Abuz potențial al contului serviciului de pinning
  • Încălcări ale conformității de securitate în mediile corporative

Blocaje pe partea serverului

Alternativa — direcționarea tuturor încărcărilor prin backend — creează mai multe probleme:

  • Costuri crescute de lățime de bandă a serverului
  • Latență mai mare pentru utilizatori
  • Cerințe de infrastructură mai complexe
  • Puncte unice potențiale de eșec

Securitatea aplicațiilor mobile

Aplicațiile mobile se confruntă cu provocări similare — cheile API stocate în pachetele aplicației pot fi extrase prin inginerie inversă.

Prezentarea tokenurilor de încărcare IPFS

Tokenurile de încărcare semnate de la IPFS.NINJA oferă un compromis securizat. Iată cum funcționează:

  1. Serverul generează tokenul: Backend-ul dvs. creează un token semnat, limitat în timp, folosind cheia API
  2. Clientul primește tokenul: Tokenul este transmis în siguranță către aplicația dvs. frontend
  3. Încărcare directă: Clienții încarcă direct pe IPFS.NINJA folosind tokenul semnat
  4. Expirare automată: Tokenurile expiră după o durată stabilită, limitând fereastra de expunere

Această abordare combină securitatea autentificării pe partea serverului cu beneficiile de performanță ale încărcărilor directe din partea clientului.

Înțelegerea securității tokenurilor de încărcare

Tokenurile de încărcare semnate folosesc semnături criptografice pentru a asigura autenticitatea fără a expune cheia API principală. Fiecare token conține:

  • Marca temporală de expirare: Invalidare automată după durata specificată
  • Constrângeri de utilizare: Limite opționale pentru numărul de fișiere sau dimensiunea totală
  • Semnătură criptografică: Previne manipularea sau falsificarea
  • Verificarea emitentului: Legătură cu contul dvs. autentificat

Spre deosebire de cheile API, tokenurile de încărcare sunt proiectate pentru a fi încorporate în siguranță în codul clientului. Chiar dacă sunt extrase, oferă acces limitat care expiră automat.

Implementarea backend-ului: exemplu Express.js

Să construim un exemplu complet care arată cum să implementați încărcări IPFS securizate din partea clientului. Mai întâi, backend-ul Express.js care generează tokenuri de încărcare:

// server.js
const express = require('express');
const cors = require('cors');
const app = express();

app.use(express.json());
app.use(cors());

// Your IPFS.NINJA API key (keep this secure on server-side only)
const IPFS_API_KEY = 'bws_1234567890abcdef1234567890abcdef12345678';

// Generate a signed upload token
app.post('/api/generate-upload-token', async (req, res) => {
  try {
    const response = await fetch('https://api.ipfs.ninja/upload-tokens', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-Api-Key': IPFS_API_KEY
      },
      body: JSON.stringify({
        expiresIn: '1h', // Token valid for 1 hour
        maxUploads: 10,  // Optional: limit number of uploads
        maxSizeMB: 50    // Optional: limit total upload size
      })
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const tokenData = await response.json();
    
    res.json({
      success: true,
      uploadToken: tokenData.token,
      expiresAt: tokenData.expiresAt
    });
  } catch (error) {
    console.error('Token generation failed:', error);
    res.status(500).json({
      success: false,
      error: 'Failed to generate upload token'
    });
  }
});

// Optional: Endpoint to verify uploads completed successfully
app.post('/api/verify-upload', async (req, res) => {
  const { cid } = req.body;
  
  try {
    // Verify the file was pinned successfully
    const response = await fetch(`https://api.ipfs.ninja/pins/${cid}`, {
      headers: {
        'X-Api-Key': IPFS_API_KEY
      }
    });

    const pinData = await response.json();
    
    res.json({
      success: true,
      verified: pinData.pinned,
      metadata: pinData
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: 'Verification failed'
    });
  }
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

Implementarea frontend-ului: încărcare securizată din partea clientului

Acum, codul frontend care încarcă în siguranță fișiere folosind tokenul semnat:

<!DOCTYPE html>
<html>
<head>
    <title>Secure IPFS Upload Demo</title>
    <style>
        body { font-family: Arial, sans-serif; max-width: 600px; margin: 50px auto; padding: 20px; }
        .upload-area { border: 2px dashed #ccc; padding: 20px; text-align: center; margin: 20px 0; }
        .upload-area.dragover { border-color: #007cba; background: #f0f8ff; }
        button { background: #007cba; color: white; border: none; padding: 10px 20px; cursor: pointer; }
        .status { margin: 10px 0; padding: 10px; border-radius: 4px; }
        .success { background: #d4edda; color: #155724; }
        .error { background: #f8d7da; color: #721c24; }
        .info { background: #d1ecf1; color: #0c5460; }
    </style>
</head>
<body>
    <h1>Secure IPFS Upload with Signed Tokens</h1>
    
    <div class="upload-area" id="uploadArea">
        <p>Drag & drop files here or click to select</p>
        <input type="file" id="fileInput" multiple style="display: none;">
        <button onclick="document.getElementById('fileInput').click()">Select Files</button>
    </div>

    <div id="status"></div>
    <div id="results"></div>

    <script>
        class SecureIPFSUploader {
            constructor() {
                this.uploadToken = null;
                this.tokenExpiry = null;
                this.setupEventListeners();
            }

            setupEventListeners() {
                const uploadArea = document.getElementById('uploadArea');
                const fileInput = document.getElementById('fileInput');

                // Drag and drop handlers
                uploadArea.addEventListener('dragover', (e) => {
                    e.preventDefault();
                    uploadArea.classList.add('dragover');
                });

                uploadArea.addEventListener('dragleave', () => {
                    uploadArea.classList.remove('dragover');
                });

                uploadArea.addEventListener('drop', (e) => {
                    e.preventDefault();
                    uploadArea.classList.remove('dragover');
                    this.handleFiles(Array.from(e.dataTransfer.files));
                });

                // File input handler
                fileInput.addEventListener('change', (e) => {
                    this.handleFiles(Array.from(e.target.files));
                });
            }

            async getUploadToken() {
                // Check if we have a valid token
                if (this.uploadToken && this.tokenExpiry && new Date() < new Date(this.tokenExpiry)) {
                    return this.uploadToken;
                }

                try {
                    this.showStatus('Generating secure upload token...', 'info');
                    
                    const response = await fetch('/api/generate-upload-token', {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json'
                        }
                    });

                    if (!response.ok) {
                        throw new Error(`Failed to generate token: ${response.statusText}`);
                    }

                    const data = await response.json();
                    
                    if (!data.success) {
                        throw new Error(data.error || 'Token generation failed');
                    }

                    this.uploadToken = data.uploadToken;
                    this.tokenExpiry = data.expiresAt;
                    
                    return this.uploadToken;
                } catch (error) {
                    this.showStatus(`Token generation failed: ${error.message}`, 'error');
                    throw error;
                }
            }

            async uploadFile(file) {
                try {
                    const token = await this.getUploadToken();
                    
                    // Convert file to base64 for JSON transport
                    const fileBase64 = await this.fileToBase64(file);
                    
                    this.showStatus(`Uploading ${file.name} to IPFS...`, 'info');

                    const response = await fetch('https://api.ipfs.ninja/upload/new', {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json',
                            'Authorization': `Signed ${token}`
                        },
                        body: JSON.stringify({
                            content: fileBase64,
                            description: `File uploaded via secure token: ${file.name}`,
                            metadata: {
                                filename: file.name,
                                fileType: file.type,
                                uploadedAt: new Date().toISOString(),
                                uploadMethod: 'signed-token'
                            }
                        })
                    });

                    if (!response.ok) {
                        const errorText = await response.text();
                        throw new Error(`Upload failed: ${response.status} ${errorText}`);
                    }

                    const result = await response.json();
                    
                    return {
                        success: true,
                        filename: file.name,
                        cid: result.cid,
                        size: result.sizeMB,
                        ipfsUri: result.uris.ipfs,
                        httpUrl: result.uris.url
                    };
                } catch (error) {
                    return {
                        success: false,
                        filename: file.name,
                        error: error.message
                    };
                }
            }

            async handleFiles(files) {
                if (files.length === 0) return;

                this.clearResults();
                
                try {
                    // Upload files concurrently
                    const uploadPromises = files.map(file => this.uploadFile(file));
                    const results = await Promise.all(uploadPromises);
                    
                    this.displayResults(results);
                    
                    const successful = results.filter(r => r.success).length;
                    const total = results.length;
                    
                    if (successful === total) {
                        this.showStatus(`✅ Successfully uploaded ${successful} file(s) to IPFS!`, 'success');
                    } else {
                        this.showStatus(`⚠️ Uploaded ${successful}/${total} files. Check results below.`, 'error');
                    }
                } catch (error) {
                    this.showStatus(`Upload failed: ${error.message}`, 'error');
                }
            }

            fileToBase64(file) {
                return new Promise((resolve, reject) => {
                    const reader = new FileReader();
                    reader.readAsDataURL(file);
                    reader.onload = () => {
                        // Remove the data:mime/type;base64, prefix
                        const base64 = reader.result.split(',')[1];
                        resolve(base64);
                    };
                    reader.onerror = error => reject(error);
                });
            }

            showStatus(message, type) {
                const statusDiv = document.getElementById('status');
                statusDiv.className = `status ${type}`;
                statusDiv.textContent = message;
            }

            displayResults(results) {
                const resultsDiv = document.getElementById('results');
                
                resultsDiv.innerHTML = '<h3>Upload Results:</h3>' + 
                    results.map(result => `
                        <div class="status ${result.success ? 'success' : 'error'}" style="margin: 10px 0;">
                            <strong>${result.filename}</strong><br>
                            ${result.success ? 
                                `✅ CID: ${result.cid}<br>
                                 📊 Size: ${result.size} MB<br>
                                 🔗 URL: <a href="${result.httpUrl}" target="_blank">${result.httpUrl}</a>` :
                                `❌ Error: ${result.error}`
                            }
                        </div>
                    `).join('');
            }

            clearResults() {
                document.getElementById('results').innerHTML = '';
            }
        }

        // Initialize the uploader
        const uploader = new SecureIPFSUploader();
    </script>
</body>
</html>

Considerații avansate de securitate

La implementarea securității încărcărilor IPFS cu tokenuri semnate, luați în considerare aceste măsuri de securitate suplimentare:

Limitări ale domeniului tokenului

Configurați tokenurile cu restricții adecvate:

// Generate token with specific constraints
const restrictedToken = await fetch('https://api.ipfs.ninja/upload-tokens', {
  method: 'POST',
  headers: {
    'X-Api-Key': IPFS_API_KEY
  },
  body: JSON.stringify({
    expiresIn: '30m',        // Short expiration
    maxUploads: 5,           // Limited upload count
    maxSizeMB: 10,          // Size restriction
    allowedMimeTypes: ['image/jpeg', 'image/png'], // File type restrictions
    ipWhitelist: ['192.168.1.0/24'] // IP-based access control
  })
});

Validarea conținutului

Validați întotdeauna conținutul încărcat pe backend-ul dvs.:

app.post('/api/validate-upload', async (req, res) => {
  const { cid } = req.body;
  
  try {
    // Fetch and validate the uploaded content
    const response = await fetch(`https://ipfs.ninja/ipfs/${cid}`);
    const contentType = response.headers.get('content-type');
    
    // Implement your validation logic
    if (!isValidContentType(contentType)) {
      // Remove invalid content
      await deleteFromIPFS(cid);
      return res.status(400).json({ error: 'Invalid content type' });
    }
    
    res.json({ success: true, validated: true });
  } catch (error) {
    res.status(500).json({ error: 'Validation failed' });
  }
});

Limitarea ratei de cereri

Implementați limitarea suplimentară a ratei pe endpoint-ul de generare a tokenurilor:

const rateLimit = require('express-rate-limit');

const tokenLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 10, // Limit each IP to 10 token requests per windowMs
  message: 'Too many token requests, please try again later'
});

app.use('/api/generate-upload-token', tokenLimiter);

Beneficii față de abordările tradiționale

Tokenurile de încărcare semnate oferă mai multe avantaje față de metodele alternative de securitate a încărcărilor IPFS:

Față de proxy pe partea serverului

  • Performanță: Încărcările directe elimină consumul de lățime de bandă al serverului
  • Scalabilitate: Fără blocaje ale serverului în perioadele de încărcare intensă
  • Cost: Costuri reduse de lățime de bandă și procesare
  • Experiența utilizatorului: Viteze mai bune de încărcare și urmărirea progresului

Față de cheile API pe partea clientului

  • Securitate: Fără riscul extragerii sau abuzului cheii API
  • Conformitate: Îndeplinește cerințele auditurilor de securitate
  • Controlul accesului: Permisiuni granulare și expirare automată
  • Monitorizare: Urmărire mai bună a surselor și tiparelor de încărcare

Față de alte servicii de pinning

IPFS.NINJA este în prezent singurul serviciu major de pinning care oferă tokenuri de încărcare semnate. Competitori precum Pinata necesită fie proxy pe partea serverului, fie expunerea cheii API pe partea clientului, ceea ce face din aceasta un factor de diferențiere unic.

Pentru mai multe detalii despre cum se compară IPFS.NINJA cu alte servicii, consultați ghidul nostru comparativ complet.

Sfaturi pentru implementarea în producție

La implementarea tokenurilor de încărcare semnate în producție:

Configurarea mediului

Stocați configurarea sensibilă în siguranță:

// Use environment variables for production
const config = {
  ipfsApiKey: process.env.IPFS_API_KEY,
  tokenExpiry: process.env.UPLOAD_TOKEN_EXPIRY || '1h',
  maxFileSize: process.env.MAX_FILE_SIZE_MB || 50,
  allowedOrigins: process.env.ALLOWED_ORIGINS?.split(',') || ['localhost:3000']
};

Monitorizare și logare

Implementați logarea completă pentru monitorizarea securității:

const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'upload-security.log' })
  ]
});

// Log token generation
logger.info('Upload token generated', {
  userId: req.user.id,
  clientIP: req.ip,
  userAgent: req.get('User-Agent'),
  expiresAt: tokenData.expiresAt
});

Gestionarea erorilor

Implementați gestionarea robustă a erorilor care nu dezvăluie informații sensibile:

app.use((error, req, res, next) => {
  // Log full error details server-side
  logger.error('Upload token error', {
    error: error.message,
    stack: error.stack,
    userId: req.user?.id,
    endpoint: req.path
  });
  
  // Send safe error message to client
  res.status(500).json({
    success: false,
    error: 'An internal error occurred. Please try again.'
  });
});

Integrarea cu framework-uri populare

Tokenurile de încărcare semnate funcționează perfect cu framework-urile web moderne. Iată exemple rapide de integrare:

React Hook

import { useState, useCallback } from 'react';

export function useSecureIPFSUpload() {
  const [uploading, setUploading] = useState(false);
  const [uploadToken, setUploadToken] = useState(null);

  const getToken = useCallback(async () => {
    if (uploadToken?.expiresAt && new Date() < new Date(uploadToken.expiresAt)) {
      return uploadToken.token;
    }

    const response = await fetch('/api/generate-upload-token', {
      method: 'POST'
    });
    const data = await response.json();
    setUploadToken(data);
    return data.uploadToken;
  }, [uploadToken]);

  const uploadFile = useCallback(async (file) => {
    setUploading(true);
    try {
      const token = await getToken();
      // Upload logic here...
    } finally {
      setUploading(false);
    }
  }, [getToken]);

  return { uploadFile, uploading };
}

Vue.js Composable

import { ref } from 'vue';

export function useSecureUpload() {
  const uploading = ref(false);
  const uploadProgress = ref(0);

  const uploadFile = async (file) => {
    uploading.value = true;
    // Implementation here...
  };

  return {
    uploading: readonly(uploading),
    uploadProgress: readonly(uploadProgress),
    uploadFile
  };
}

Concluzie

Tokenurile de încărcare semnate rezolvă o provocare critică de securitate în dezvoltarea aplicațiilor descentralizate. Oferind o modalitate sigură de a permite încărcări directe din partea clientului pe IPFS fără a expune cheile API, ele deschid noi posibilități arhitecturale pentru aplicațiile web moderne.

Indiferent dacă construiți un sistem de gestionare a conținutului, un marketplace NFT sau orice aplicație care necesită încărcări securizate de fișiere, tokenurile de încărcare IPFS.NINJA oferă securitatea și flexibilitatea de care aveți nevoie. Implementarea este simplă, beneficiile de securitate sunt semnificative, iar câștigurile de performanță sunt substanțiale.

Pentru a afla mai multe despre fundamentele IPFS, consultați ghidul nostru despre ce este IPFS pinning sau explorați tutorialul complet al API-ului. Pentru dezvoltatorii care evaluează diferite opțiuni, comparația noastră a celor mai bune servicii de pinning IPFS oferă informații complete.

Sunteți gata să implementați încărcări IPFS securizate din partea clientului în aplicația dvs.? Combinația de practici moderne de securitate și stocare descentralizată face din această abordare alegerea ideală pentru aplicațiile de producție care trebuie să se scaleze menținând standardele de securitate.

Gata să începeți pinning-ul? Creați un cont gratuit — 500 fișiere, 1 GB stocare, gateway dedicat. Nu este necesară cartea de credit.

Share:
Înapoi la Blog

Articole Similare

Vezi Toate Articolele »