$ $
Installation
Configurer un alias persistant (une fois)
curl -s https://cpynet.com/install.sh -o install.sh && bash -n install.sh && . install.shSHA256 de install.sh : 86bd4b2171ea3f0e8e845df8585e69a3d452eb94855bbab7dd097c8af9b96887
Lire install.sh avant de l'exécuter
# cpynet installer - fetches the cpy/pst shell functions from https://cpynet.com/alias,
# adds a source line to your shell's rc file (once, never duplicated), and
# loads them into this session right now.
#
# Dot-sourced (". install.sh"), not run as a subprocess - that's what makes
# cpy/pst usable immediately in this terminal, not just in new ones.
CPYNET_RC=~/.bashrc
[ -n "$ZSH_VERSION" ] && CPYNET_RC=~/.zshrc
if curl -s https://cpynet.com/alias -o ~/.cpy.sh && bash -n ~/.cpy.sh; then
grep -qxF 'source ~/.cpy.sh' "$CPYNET_RC" || echo 'source ~/.cpy.sh' >> "$CPYNET_RC"
. ~/.cpy.sh
echo "cpynet installed - cpy and pst are ready"
else
echo "install failed, try again"
fi
unset CPYNET_RC
SHA256 du script téléchargé par install.sh (~/.cpy.sh) : 8161c889a7240a3958267ffdb1697cff311246b5c4aaf57c02d44aa1d397a17e
Lisez aussi ce script (fonctionne aussi comme installation manuelle - copiez directement la fonction ci-dessous)
cpy() {
local password="" ttl="" reads="" e2e="" a
for a in "$@"; do case "$a" in
-password=*) password="${a#-password=}" ;;
-ttl=*) ttl="${a#-ttl=}" ;;
-reads=*) reads="${a#-reads=}" ;;
-e) e2e=1 ;;
esac; done
local qs=""
[ -n "$ttl" ] && qs="ttl=$ttl"
[ -n "$reads" ] && qs="${qs:+$qs&}reads=$reads"
local target="https://llmtag.com/"
[ -n "$qs" ] && target="https://llmtag.com/?$qs"
local input key=""
if [ -n "$e2e" ]; then
key=$(openssl rand -base64 24)
input=$(openssl enc -aes-256-cbc -pbkdf2 -salt -a -A -pass "pass:$key") || return 1
else
input=$(cat)
fi
local url
if [ -n "$password" ]; then
url=$(printf '%s' "$input" | curl -sS --fail-with-body -L -H "X-Password: $password" --data-binary @- "$target") || return 1
else
url=$(printf '%s' "$input" | curl -sS --fail-with-body -L --data-binary @- "$target") || return 1
fi
local bare="${url%%\?*}"
echo "${bare##*/}"
echo "curl \"$url\""
if [ -n "$key" ]; then
echo "key (share separately, never with the link/code): $key"
fi
}
pst() {
local password="" id="" key="" a
for a in "$@"; do case "$a" in
-password=*) password="${a#-password=}" ;;
-key=*) key="${a#-key=}" ;;
*) id="$a" ;;
esac; done
if [ -z "$id" ]; then echo "usage: pst <code> [-password=xxx] [-key=xxx]" >&2; return 1; fi
local target="https://llmtag.com/$id"
[ -n "$password" ] && target="$target?p=$password"
local text
text=$(curl -sS --fail-with-body "$target") || return 1
if [ -n "$key" ]; then
text=$(printf '%s' "$text" | openssl enc -d -aes-256-cbc -pbkdf2 -a -A -pass "pass:$key") || { echo "decrypt failed - wrong key?" >&2; return 1; }
fi
printf '%s\n' "$text"
if command -v pbcopy >/dev/null 2>&1; then printf '%s' "$text" | pbcopy
elif command -v wl-copy >/dev/null 2>&1; then printf '%s' "$text" | wl-copy
elif command -v xclip >/dev/null 2>&1; then printf '%s' "$text" | xclip -selection clipboard
elif command -v xsel >/dev/null 2>&1; then printf '%s' "$text" | xsel --clipboard
elif command -v clip.exe >/dev/null 2>&1; then printf '%s' "$text" | clip.exe
fi
}
Ensuite, simplement : commande | cpy — affiche le code à 6 chiffres et une commande curl prête à l'emploi sur deux lignes. Pour le protéger par mot de passe : commande | cpy -password=xxx. Pour la lecture : pst 123456 — affiche le contenu sur stdout et le copie aussi dans le presse-papiers si possible (pbcopy/wl-copy/xclip/xsel/clip.exe).
Les liens sont générés sur le domaine court https://llmtag.com ; la commande d'installation ci-dessus se télécharge depuis le site principal, https://cpynet.com - même service, juste un domaine court séparé réservé aux liens.
Windows / PowerShell
Invoke-RestMethod https://cpynet.com/install.ps1 -OutFile install.ps1; . .\install.ps1SHA256 de install.ps1 : 0ab2333a4ea86b1b8797c2b8251daa368d485dfeaa6dfcaad90c076d0217b43c
Lire install.ps1 avant de l'exécuter
# cpynet installer - fetches the cpy/pst PowerShell functions from
# https://cpynet.com/alias.ps1, adds a dot-source line to $PROFILE (once, never duplicated),
# and loads them into this session right now.
#
# Dot-sourced (". .\install.ps1"), not run as a subprocess - that's what
# makes cpy/pst usable immediately in this session, not just in new ones.
$ErrorActionPreference = 'Stop'
try {
Invoke-RestMethod https://cpynet.com/alias.ps1 -OutFile "$HOME/.cpy.ps1"
if (-not (Test-Path $PROFILE)) { New-Item -ItemType File -Path $PROFILE -Force | Out-Null }
if (-not (Select-String -Path $PROFILE -Pattern '\.cpy\.ps1' -Quiet -ErrorAction SilentlyContinue)) {
Add-Content $PROFILE "`n. `"$HOME/.cpy.ps1`""
}
. "$HOME/.cpy.ps1"
Write-Output "cpynet installed - cpy and pst are ready"
} catch {
Write-Output "install failed, try again"
}
SHA256 du script téléchargé par install.ps1 (~/.cpy.ps1) : 356ae02c39d58c86d717899969cf961e519eac156105140671c63941b9b5aa17
Lisez aussi ce script (fonctionne aussi comme installation manuelle - copiez directement les fonctions ci-dessous)
function cpy {
[CmdletBinding()]
param(
[Parameter(ValueFromPipeline = $true)]
[string[]]$InputObject,
[string]$Password = "",
[string]$Ttl = "",
[string]$Reads = ""
)
begin { $lines = New-Object System.Collections.Generic.List[string] }
process { if ($null -ne $InputObject) { foreach ($l in $InputObject) { $lines.Add($l) } } }
end {
$text = $lines -join "`n"
$qs = @()
if ($Ttl) { $qs += "ttl=$Ttl" }
if ($Reads) { $qs += "reads=$Reads" }
$target = "https://llmtag.com/"
if ($qs.Count -gt 0) { $target = "https://llmtag.com/?" + ($qs -join '&') }
$headers = @{}
if ($Password) { $headers["X-Password"] = $Password }
try {
$url = (Invoke-RestMethod -Uri $target -Method Post -Body $text -Headers $headers -ContentType "text/plain; charset=utf-8").Trim()
} catch {
Write-Error $_
return
}
$bare = $url -replace '\?.*$', ''
$code = $bare -replace '.*/', ''
Write-Output $code
Write-Output "curl `"$url`""
}
}
function pst {
[CmdletBinding()]
param(
[Parameter(Position = 0)]
[string]$Code = "",
[string]$Password = ""
)
if (-not $Code) { Write-Error "usage: pst <code> [-Password xxx]"; return }
$target = "https://llmtag.com/$Code"
if ($Password) { $target = "$target`?p=$Password" }
try {
$text = Invoke-RestMethod -Uri $target -Method Get
} catch {
Write-Error $_
return
}
Write-Output $text
if (Get-Command Set-Clipboard -ErrorAction SilentlyContinue) {
$text | Set-Clipboard
}
}
Cela ajoute les fonctions cpy/pst à $PROFILE une fois - ensuite, "texte" | cpy et pst 123456 fonctionnent comme la version bash (les paramètres utilisent le style propre à PowerShell : cpy -Ttl 1h -Reads 3 -Password xxx, pst 123456 -Password xxx).
Utilisation
Utiliser l'interface web
1. Écrivez votre texte
Collez votre texte ou code dans l'onglet écrire, cliquez sur envoyer.
2. Partagez le code, le lien ou le QR
L'envoi génère un code à 6 chiffres, une commande curl prête à l'emploi et un code QR scannable.
3. Entrez le code
Dans l'onglet lire, entrez le code — ou scannez le code QR avec un téléphone.
4. Lu une fois, puis disparu
Le contenu s'affiche instantanément et est définitivement supprimé du serveur — le même code ne fonctionnera pas une seconde fois.
Envoyer depuis le terminal
commande | curl --data-binary @- https://llmtag.com/La réponse est un lien nu, prêt à l'emploi.
Lire depuis le terminal
curl "votre-lien"Lu une fois, puis supprimé définitivement. Alias installé ci-dessus ? pst 123456.
Protéger par mot de passe
Remplissez le champ mot de passe ci-dessous — le lien inclura automatiquement ?p=motdepasse.
Windows / PowerShell
Invoke-RestMethod -Method Post -Body "texte" -Uri https://llmtag.com/Invoke-RestMethod "votre-lien"L'Invoke-RestMethod intégré fonctionne aussi, à la place de curl.exe.
Intégration API / CI
Ajoutez Accept: application/json à la requête de création pour recevoir {"code","url","expires_at"} au lieu de texte brut - plus facile à analyser dans un script. Référence complète, y compris les codes de statut (400/401/404/413/429/503) et un exemple GitHub Actions : /api.
Questions fréquentes
Combien de fois un code peut-il être utilisé ?
Une seule fois. Il est définitivement supprimé du serveur à l'instant où il est lu.
Que se passe-t-il quand le délai expire ?
Même si personne ne le lit, le paste est automatiquement supprimé - aucune trace ne subsiste sur le serveur.
Comment l'utiliser si mon presse-papiers est désactivé ?
CPYNET ne touche jamais au presse-papiers - tout transite via curl depuis le terminal, donc un presse-papiers désactivé n'a aucune importance.
Le serveur voit-il ou stocke-t-il ce que je colle ?
Le texte n'est conservé qu'en mémoire, jamais écrit sur disque - il est définitivement supprimé au moment de sa lecture ou à l'expiration du délai. S'il est protégé par mot de passe, il est conservé chiffré avec AES-256-GCM.
Est-ce que ça fonctionne sous Windows ?
Oui - sous PowerShell, tapez curl.exe au lieu de l'alias curl, sinon les textes longs peuvent être tronqués dans la console. Ou utilisez l'Invoke-RestMethod intégré, ou installez les fonctions cpy/pst via la section Windows / PowerShell ci-dessus.
Quelle est la taille maximale et la longueur du code ?
Jusqu'à 2 MB, un code à 6 chiffres, s'autosupprime par défaut en 2min - sélectionnable jusqu'à 1j (le paramètre ?ttl=, ou le sélecteur TTL de l'onglet écrire). S'autodétruit après 1 lecture par défaut - sélectionnable jusqu'à 10 lectures (le paramètre ?reads=, ou le sélecteur de lectures).
Pourquoi CPYNET ?
Conçu pour les environnements où le partage du presse-papiers n'est pas possible : serveurs distants via SSH, machines dont l'accès au presse-papiers est verrouillé par une politique, ou machines/conteneurs/bureaux virtuels séparés sans presse-papiers partagé entre eux. CPYNET ne touche jamais au presse-papiers du système d'exploitation - tout circule en texte brut via curl - il peut donc être utilisé en toute confiance même là où le presse-papiers est entièrement désactivé.
Fonctionnalités
- Lecture unique : supprimé définitivement au moment de la lecture
- Suppression automatique à l'expiration du délai, même si personne ne le lit
- Partage protégé par mot de passe : AES-256-GCM + PBKDF2, le serveur ne détient le texte en clair que momentanément
- Notification en direct : votre onglet est informé à l'instant de la lecture (SSE)
- Prise en charge des petits fichiers (extensions autorisées uniquement, conservés au maximum 1 h) : 📎 pour en joindre un, retéléchargé avec son nom de fichier et type de contenu d'origine
- Limitation de débit par IP : protège contre la devinette de code et les attaques par force brute
Extensions de fichier autorisées : .txt, .log, .csv, .json, .md, .pdf, .doc, .docx, .rtf, .xml, .yaml, .yml, .pem, .crt, .key, .conf, .cfg, .env, .ini, .toml
Sécurité
Le serveur n'exécute, n'évalue ni ne redirige jamais ce que vous collez vers un shell - il se contente de le stocker et de le renvoyer exactement tel que reçu. Aucune dépendance tierce (bibliothèque standard Go pure), aucun accès au système de fichiers avec des données utilisateur, aucune requête sortante.
Chiffrement à connaissance nulle (le serveur ne peut jamais le voir)
L'icône du bouclier (🔒) dans l'onglet écrire, ou cpy -e depuis un terminal, est une couche différente du mot de passe ci-dessus : avec un mot de passe, le serveur déchiffre brièvement le texte lui-même pour le vérifier ; ici, le chiffrement se fait entièrement de votre côté - le serveur ne voit jamais rien d'autre que du texte chiffré.
- Votre navigateur (ou cpy -e) génère une clé aléatoire - elle ne quitte jamais votre machine.
- Le texte est chiffré avec cette clé, dans le navigateur (WebCrypto AES-256-GCM) ou le terminal (openssl).
- Seul le texte chiffré est envoyé au serveur, et c'est tout ce qu'il stocke jamais - il ne voit jamais le texte en clair.
- La clé voyage dans la partie #key= du lien (les navigateurs n'envoient jamais le fragment au serveur) ou est transmise séparément avec pst -key= dans un terminal - le lien/code seul est inutile sans elle.
⚠️ Avertissement : cela n'élimine pas le risque de rediriger quelque chose vers un shell (curl ... | bash) sans l'examiner au préalable - c'est un risque universel pour tout outil de partage, pas spécifique à celui-ci. N'exécutez jamais une commande que vous n'avez pas examinée provenant d'une source à laquelle vous ne faites pas confiance.
Limites
Taille max : 2 MB · Code : 6 chiffres · Suppression automatique : 2min par défaut, sélectionnable jusqu'à 1j · Lectures : 1 par défaut, jusqu'à 10
CPYNET v1.0 — un seul fichier, un seul binaire Go — pas de base de données externe ni de dépendances.