streaak/keyhacksCollection organisée de commandes pour valider des clés API divulguées provenant de programmes de bug bounty et de tests d'intrusion, couvrant plus de 80 services dont AWS, GitHub, Slack et Twilio.
KeyHacks montre des méthodes pour valider différentes clés API trouvées lors d'un programme Bug Bounty ou d'un test d'intrusion.
@Gwen001 a scripté l'ensemble du processus disponible ici et il se trouve ici
Si la commande ci-dessous renvoie missing_text_or_fallback_or_attachments, cela signifie que l'URL est valide, toute autre réponse signifierait que l'URL est invalide.```
curl -s -X POST -H "Content-type: application/json" -d '{"text":""}' "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX"
## [Jeton API Slack](https://api.slack.com/web)```
curl -sX POST "https://slack.com/api/auth.test?token=xoxp-TOKEN_HERE&pretty=1"
ou``` curl -sX POST "https://slack.com/api/auth.test" -H "Accept: application/json; charset=utf-8" -H "Authorization: Bearer xoxb-TOKEN_HERE"
## [SauceLabs Nom d'utilisateur et clé d'accès](https://wiki.saucelabs.com/display/DOCS/Account+Methods)```
curl -u USERNAME:ACCESS_KEY https://saucelabs.com/rest/v1/users/USERNAME
Vous pouvez générer des jetons d'accès en visitant l'URL ci-dessous.``` https://graph.facebook.com/oauth/access_token?client_id=ID_HERE&client_secret=SECRET_HERE&redirect_uri=&grant_type=client_credentials
## Jeton d'accès Facebook```
https://developers.facebook.com/tools/debug/accesstoken/?access_token=ACCESS_TOKEN_HERE&version=v3.2
Nécessite un jeton personnalisé et une clé API.
curl -s -XPOST -H 'content-type: application/json' -d '{"token":":custom_token","returnSecureToken":True}' 'https://identitytoolkit.googleapis.com/v1/accounts:signInWithCustomToken?key=:api_key'curl -s -XPOST -H 'content-type: application/json' -d '{"idToken":":id_token"}' https://www.googleapis.com/identitytoolkit/v3/relyingparty/verifyCustomToken?key=:api_key'curl -s -u "user:apikey" https://api.github.com/user curl -s -H "Authorization: token TOKEN_HERE" "https://api.github.com/users/USERNAME_HERE/orgs"
curl "https://api.github.com/rate_limit" -i -u "user:apikey" | grep "X-OAuth-Scopes:"
## [Identifiant client Github et secret client](https://developer.github.com/v3/#oauth2-keysecret)```
curl 'https://api.github.com/users/whatever?client_id=xxxx&client_secret=yyyy'
Référence : https://abss.me/posts/fcm-takeover``` curl -s -X POST --header "Authorization: key=AI..." --header "Content-Type:application/json" 'https://fcm.googleapis.com/fcm/send' -d '{"registration_ids":["1"]}'
## Clé SSH privée GitHub
Les clés SSH privées peuvent être testées sur github.com pour vérifier si elles sont associées à un compte utilisateur existant. Si la clé existe, le nom d'utilisateur correspondant à la clé sera fourni. ([source](https://github.com/streaak/keyhacks/issues/2))```
$ ssh -i <path to SSH private key> -T [email protected]
Hi <username>! You've successfully authenticated, but GitHub does not provide shell access.
curl -X GET 'https://api.twilio.com/2010-04-01/Accounts.json' -u ACCOUNT_SID:AUTH_TOKEN
## [Secret de l'API Twitter](https://developer.twitter.com/en/docs/basics/authentication/guides/bearer-tokens.html)```
curl -u 'API key:API secret key' --data 'grant_type=client_credentials' 'https://api.twitter.com/oauth2/token'
curl --request GET --url https://api.twitter.com/1.1/account_activity/all/subscriptions/count.json --header 'authorization: Bearer TOKEN'
## [HubSpot API key](https://developers.hubspot.com/docs/methods/owners/get_owners)
Obtenir tous les propriétaires :```
https://api.hubapi.com/owners/v2/owners?hapikey={keyhere}
Obtenez tous les détails de contact :``` https://api.hubapi.com/contacts/v1/lists/all/contacts/all?hapikey={keyhere}
## [Clé API Infura](https://docs.infura.io/infura/networks/ethereum/how-to/secure-a-project/project-id)```
curl https://mainnet.infura.io/v3/<YOUR-API-KEY> -X POST -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","method":"eth_accounts","params":[],"id":1}'
curl https://www.deviantart.com/oauth2/token -d grant_type=client_credentials -d client_id=ID_HERE -d client_secret=mysecret
## [Jeton d'accès Deviant Art](https://www.deviantart.com/developers/authentication)```
curl https://www.deviantart.com/api/v1/oauth2/placebo -d access_token=Alph4num3r1ct0k3nv4lu3
curl -X GET https://app.pendo.io/api/v1/feature -H 'content-type: application/json' -H 'x-pendo-integration-key:KEY_HERE' curl -X GET https://app.pendo.io/api/v1/metadata/schema/account -H 'content-type: application/json' -H 'x-pendo-integration-key:KEY_HERE'
## [Jeton API SendGrid](https://docs.sendgrid.com/api-reference)```
curl -X "GET" "https://api.sendgrid.com/v3/scopes" -H "Authorization: Bearer SENDGRID_TOKEN-HERE" -H "Content-Type: application/json"
Détection :
ID d'application / secret client : sq0[a-z]{3}-[0-9A-Za-z\-_]{22,43}
Jeton d'authentification : EAAA[a-zA-Z0-9]{60}
ID d'application de test et secret client :``` curl "https://squareup.com/oauth2/revoke" -d '{"access_token":"[RANDOM_STRING]","client_id":"[APP_ID]"}' -H "Content-Type: application/json" -H "Authorization: Client [CLIENT_SECRET]"
Réponse indiquant des identifiants valides :```
empty
Réponse indiquant des informations d'identification invalides :``` { "message": "Not Authorized", "type": "service.not_authorized" }
**Jeton d'authentification de test:**```
curl https://connect.squareup.com/v2/locations -H "Authorization: Bearer [AUHT_TOKEN]"
Réponse indiquant des informations d'identification valides:``` {"locations":[{"id":"CBASELqoYPXr7RtT-9BRMlxGpfcgAQ","name":"Coffee \u0026 Toffee SF","address":{"address_line_1":"1455 Market Street","locality":"San Francisco","administrative_district_level_1":"CA","postal_code":"94103","country":"US"},"timezone":"America/Los_Angeles"........
Réponse indiquant des identifiants invalides :```
{"errors":[{"category":"AUTHENTICATION_ERROR","code":"UNAUTHORIZED","detail":"This request could not be authorized."}]}
curl -v https://cdn.contentful.com/spaces/SPACE_ID_HERE/entries\?access_token\=ACCESS_TOKEN_HERE
## [Dropbox API](https://www.dropbox.com/developers/documentation/http/documentation)```
curl -X POST https://api.dropboxapi.com/2/users/get_current_account --header "Authorization: Bearer TOKEN_HERE"
Installez awscli, définissez la clé d'accès et le secret dans les variables d'environnement, et exécutez la commande suivante :``` AWS_ACCESS_KEY_ID=xxxx AWS_SECRET_ACCESS_KEY=yyyy aws sts get-caller-identity
Les permissions des identifiants AWS peuvent être déterminées en utilisant [Enumerate-IAM](https://github.com/andresriancho/enumerate-iam). Cela donne une vue plus large des privilèges des identifiants AWS découverts plutôt que de simplement vérifier les buckets S3.```
git clone https://github.com/andresriancho/enumerate-iam
cd enumerate-iam
./enumerate-iam.py --access-key AKIA... --secret-key StF0q...
--url https://api.lokalise.com/api2/projects/
--header 'x-api-token: [API-KEY-HERE]'
## [Clé privée MailGun](https://documentation.mailgun.com/en/latest/api_reference.html)```
curl --user 'api:YOUR_API_KEY' "https://api.mailgun.net/v3/domains"
curl -v -u [email protected]:test -X GET 'https://domain.freshdesk.com/api/v2/groups/1' This requires the API key in '[email protected]', pass in 'test' and 'domain.freshdesk.com' to be the instance url of the target. In case you get a 403, try the endpoint api/v2/tickets, which is accessible for all keys.
## [Clé API JumpCloud](https://docs.jumpcloud.com/1.0/authentication-and-authorization/authentication-and-authorization-overview)
#### [v1](https://docs.jumpcloud.com/1.0/systemusers)```
List systems:
curl -H "x-api-key: APIKEYHERE" "https://console.jumpcloud.com/api/systems"
curl -H "x-api-key: APIKEYHERE" "https://console.jumpcloud.com/api/systemusers"
curl -H "x-api-key: APIKEYHERE" "https://console.jumpcloud.com/api/applications"
List systems:
curl -X GET https://console.jumpcloud.com/api/v2/systems/{System_ID}/memberof
-H 'Accept: application/json'
-H 'Content-Type: application/json'
-H 'x-api-key: {API_KEY}'
## Locataire Microsoft Azure
Format:```
CLIENT_ID: [0-9a-z\-]{36}
CLIENT_SECRET: [0-9A-Za-z\+\=]{40,50}
TENANT_ID: [0-9a-z\-]{36}
Vérification:``` curl -X POST -H "Content-Type: application/x-www-form-urlencoded" -d 'client_id=<CLIENT_ID>&scope=https%3A%2F%2Fgraph.microsoft.com%2F.default&client_secret=<CLIENT_SECRET>&grant_type=client_credentials' 'https://login.microsoftonline.com/<TENANT_ID>/oauth2/v2.0/token'
## [Microsoft Signatures d'accès partagé (SAS)](https://github.com/MicrosoftDocs/azure-docs/blob/master/articles/storage/common/storage-dotnet-shared-access-signature-part-1.md)
La commande PowerShell suivante peut être utilisée pour tester un jeton de signature d'accès partagé :```powershell
static void UseAccountSAS(string sasToken)
{
// Create new storage credentials using the SAS token.
StorageCredentials accountSAS = new StorageCredentials(sasToken);
// Use these credentials and the account name to create a Blob service client.
CloudStorageAccount accountWithSAS = new CloudStorageAccount(accountSAS, "account-name", endpointSuffix: null, useHttps: true);
CloudBlobClient blobClientWithSAS = accountWithSAS.CreateCloudBlobClient();
// Now set the service properties for the Blob client created with the SAS.
blobClientWithSAS.SetServiceProperties(new ServiceProperties()
{
HourMetrics = new MetricsProperties()
{
MetricsLevel = MetricsLevel.ServiceAndApi,
RetentionDays = 7,
Version = "1.0"
},
MinuteMetrics = new MetricsProperties()
{
MetricsLevel = MetricsLevel.ServiceAndApi,
RetentionDays = 7,
Version = "1.0"
},
Logging = new LoggingProperties()
{
LoggingOperations = LoggingOperations.All,
RetentionDays = 14,
Version = "1.0"
}
});
// The permissions granted by the account SAS also permit you to retrieve service properties.
ServiceProperties serviceProperties = blobClientWithSAS.GetServiceProperties();
Console.WriteLine(serviceProperties.HourMetrics.MetricsLevel);
Console.WriteLine(serviceProperties.HourMetrics.RetentionDays);
Console.WriteLine(serviceProperties.HourMetrics.Version);
}
Si la commande ci-dessous renvoie Summary or Text is required., cela signifie que l'URL est valide. Si elle renvoie Invalid webhook URL ou toute autre réponse, cela signifie que l'URL est invalide.```
curl -H "Content-Type:application/json" -d "{'text':''}" "YOUR_WEBHOOK_URL"
## [Clé d'API personnelle New Relic (NerdGraph)](https://docs.newrelic.com/docs/apis/nerdgraph/get-started/introduction-new-relic-nerdgraph#endpoint)```
curl -X POST https://api.newrelic.com/graphql \
-H 'Content-Type: application/json' \
-H 'API-Key: YOUR_API_KEY' \
-d '{ "query": "{ requestContext { userId apiKey } }" } '
curl -X GET 'https://api.newrelic.com/v2/applications.json'
-H "X-Api-Key:${APIKEY}" -i
Si valide, testez plus loin pour voir s'il s'agit d'une [clé admin](https://docs.newrelic.com/docs/apis/get-started/intro-apis/types-new-relic-api-keys#admin)
## [Clé API Heroku](https://devcenter.heroku.com/articles/platform-api-quickstart)```
curl -X POST https://api.heroku.com/apps -H "Accept: application/vnd.heroku+json; version=3" -H "Authorization: Bearer API_KEY_HERE"
Les clés secrètes Mapbox commencent par sk, les autres commencent par pk (token public), sk (token secret) ou tk (token temporaire).```
curl "https://api.mapbox.com/geocoding/v5/mapbox.places/Los%20Angeles.json?access_token=ACCESS_TOKEN"
#Check token validity curl "https://api.mapbox.com/tokens/v2?access_token=YOUR_MAPBOX_ACCESS_TOKEN"
#Get list of all tokens associated with an account. (only works if the token is a Secret Token (sk), and has the appropiate scope) curl "https://api.mapbox.com/tokens/v2/MAPBOX_USERNAME_HERE?access_token=YOUR_MAPBOX_ACCESS_TOKEN"
## [Clé API Salesforce](https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/quickstart_oauth.htm)```
curl https://instance_name.salesforce.com/services/data/v20.0/ -H 'Authorization: Bearer access_token_here'
Si la clé a la permission listIndexes, vous pouvez lister les index avec :```
curl --request GET
--url https://-1.algolianet.com/1/indexes/
--header 'content-type: application/json'
--header 'x-algolia-api-key: '
--header 'x-algolia-application-id: '
Sinon, vous devrez connaître le nom d'un index (vérifiez le code source de l'application ou les requêtes qu'elle effectue). Ensuite, pour énumérer son contenu:```
curl --request GET \
--url https://<example-app-id>-1.algolianet.com/1/indexes/<example-index> \
--header 'content-type: application/json' \
--header 'x-algolia-api-key: <example-key>' \
--header 'x-algolia-application-id: <example-appid>'
Soyez prudent lors de l'exécution de cette commande, car le payload pourrait s'exécuter dans un environnement administratif, selon l'index pour lequel vous modifiez le highlightPreTag. Il est recommandé d'utiliser un payload plus discret (comme XSS Hunter) pour prouver l'attaque de cross-site scripting possible.```
curl --request PUT
--url https://-1.algolianet.com/1/indexes//settings
--header 'content-type: application/json'
--header 'x-algolia-api-key: '
--header 'x-algolia-application-id: '
--data '{"highlightPreTag": ""}'
## [Jeton Webhook Zapier](https://zapier.com/help/how-get-started-webhooks-zapier/)```
curl -H "Accept: application/json" -H "Content-Type: application/json" -X POST -d '{"name":"streaak"}' "webhook_url_here"
curl -H "Accept: application/vnd.pagerduty+json;version=2" -H "Authorization: Token token=TOKEN_HERE" -X GET "https://api.pagerduty.com/schedules"
## [Clé d'accès BrowserStack](https://www.browserstack.com/automate/rest-api)```
curl -u "USERNAME:ACCESS_KEY" https://api.browserstack.com/automate/plan.json
Les restrictions de clé sont définies par service. Lors du test de la clé, si celle-ci est restreinte/inactive sur un service, essayez-la avec un autre.
*La tarification est en USD pour 1000 requêtes (pour les 100 000 premières requêtes)
Plus d'informations disponibles ici-
https://github.com/ozguralp/gmapsapiscanner/
https://developers.google.com/maps/api-key-best-practices
Envoyez une requête POST à l'URL suivante :``` https://www.google.com/recaptcha/api/siteverify
`secret` et `response` sont deux paramètres POST obligatoires, où `secret` est la clé et `response` est la réponse à tester.
Expression régulière : `^6[0-9a-zA-Z_-]{39}$`. La clé API commence toujours par un 6 et fait 40 caractères. En savoir plus ici : https://developers.google.com/recaptcha/docs/verify.
## [Identifiants de compte de service Google Cloud](https://cloud.google.com/docs/authentication/production)
Les identifiants de compte de service peuvent être trouvés dans un fichier JSON comme celui-ci :```
$ cat service_account.json
{
"type": "service_account",
"project_id": "...",
"private_key_id": "...",
"private_key": "-----BEGIN PRIVATE KEY-----...-----END PRIVATE KEY-----\n",
"client_email": "...",
"client_id": "...",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"token_uri": "https://oauth2.googleapis.com/token",
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/..."
}
Si c'est votre cas, vous pouvez vérifier ces informations d'identification à l'aide de l'outil gcloud (comment installer gcloud):```
$ gcloud auth activate-service-account --key-file=service_account.json
Activated service account credentials for: [...]
$ gcloud auth print-access-token
ya29.c...
En cas de succès, vous verrez le jeton d'accès imprimé dans le terminal. Veuillez noter qu'après avoir vérifié que les identifiants sont réellement valides, vous pouvez énumérer les permissions de ces identifiants, ce qui est une autre histoire.
## [Clé et secret Branch.IO](https://docs.branch.io/pages/apps/deep-linking-api/#app-read)
Visitez l'URL suivante pour vérifier la validité :```
https://api2.branch.io/v1/app/KEY_HERE?branch_secret=SECRET_HERE
Visitez ce lien pour vérifier la validité de la clé. La réponse d'une clé valide doit commencer par `authenticationResultCode: "ValidCredentials"```` https://dev.virtualearth.net/REST/v1/Locations?CountryRegion=US&adminDistrict=WA&locality=Somewhere&postalCode=98001&addressLine=100%20Main%20St.&key=API_KEY
## [Token d'accès Bit.ly](https://dev.bitly.com/authentication.html)
Visitez l'URL suivante pour vérifier la validité :```
https://api-ssl.bitly.com/v3/shorten?access_token=ACCESS_TOKEN&longUrl=https://www.google.com
curl -H "Authorization: Bearer ACCESS_TOKEN"
https://api.buildkite.com/v2/access-token
## [ButterCMS-API-Key](https://buttercms.com/docs/api/#authentication)```
curl -X GET 'https://api.buttercms.com/v2/posts/?auth_token=your_api_token'
curl -H "Authorization: Bearer ACCESS_TOKEN" https://app.asana.com/api/1.0/users/me
## [Jeton d'accès Zendesk](https://support.zendesk.com/hc/en-us/articles/203663836-Using-OAuth-authentication-with-your-application)```
curl https://{subdomain}.zendesk.com/api/v2/tickets.json \
-H "Authorization: Bearer ACCESS_TOKEN"
Les jetons API sont différents des jetons OAuth, les jetons API sont des mots de passe générés automatiquement dans l'interface d'administration du Support.``` curl https://{target}.zendesk.com/api/v2/users.json \ -u support@{target}.com/token:{here your token}
## [Clé API MailChimp](https://developer.mailchimp.com/documentation/mailchimp/reference/overview/)```
curl --request GET --url 'https://<dc>.api.mailchimp.com/3.0/' --user 'anystring:<API_KEY>' --include
Ce problème peut être davantage exploité en consultant le gist de @hateshape : https://gist.github.com/hateshape/2e671ea71d7c243fac7ebf51fb738f0a.``` curl "https://api.wpengine.com/1.2/?method=site&account_name=ACCOUNT_NAME&wpe_apikey=WPENGINE_APIKEY"
## [Clé API DataDog](https://docs.datadoghq.com/api/)```
curl "https://api.datadoghq.com/api/v1/dashboard?api_key=<api_key>&application_key=<application_key>"
Ne supprimez pas le : à la fin.```
curl https://api.delighted.com/v1/metrics.json
-H "Content-Type: application/json"
-u YOUR_DELIGHTED_API_KEY:
## [Jeton API Travis CI](https://developer.travis-ci.com/gettingstarted)```
curl -H "Travis-API-Version: 3" -H "Authorization: token <TOKEN>" https://api.travis-ci.org/repos
curl https://api.telegram.org/bot/getMe
## [WakaTime API Key](https://wakatime.com/developers)```
curl "https://wakatime.com/api/v1/users/current?api_key=KEY_HERE"
curl -u : "https://sonarcloud.io/api/authentication/validate"
## [Jeton d'accès Spotify](https://developer.spotify.com/documentation/general/guides/authorization-guide/)```
curl -H "Authorization: Bearer <ACCESS_TOKEN>" https://api.spotify.com/v1/me
Ex.: IGQVJ...``` curl -X GET 'https://graph.instagram.com/{user-id}?fields=id,username&access_token={access-token}'
## [Jeton d'accès à l'API Graph Instagram](https://developers.facebook.com/docs/instagram-api/getting-started)
Ex. : EAAJjmJ...```
curl -i -X GET 'https://graph.facebook.com/v8.0/me/accounts?access_token={access-token}'
curl "https://gitlab.example.com/api/v4/projects?private_token=<your_access_token>"
## [Jeton d'enregistrement du runner GitLab](https://docs.gitlab.com/runner/register/)```
docker run --rm gitlab/gitlab-runner register \
--non-interactive \
--executor "docker" \
--docker-image alpine:latest \
--url "https://gitlab.com/" \
--registration-token "PROJECT_REGISTRATION_TOKEN" \
--description "keyhacks-test" \
--maintenance-note "Testing token with keyhacks" \
--tag-list "docker,aws" \
--run-untagged="true" \
--locked="false" \
--access-level="not_protected"
curl -v https://api.sandbox.paypal.com/v1/oauth2/token
-H "Accept: application/json"
-H "Accept-Language: en_US"
-u "client_id:secret"
-d "grant_type=client_credentials"
Le jeton d'accès peut ensuite être utilisé pour extraire des données de l'API PayPal. Plus d'informations : https://developer.paypal.com/docs/api/overview/#make-rest-api-calls.
Ceci peut être vérifié en utilisant :```
curl -v -X GET "https://api.sandbox.paypal.com/v1/identity/oauth2/userinfo?schema=paypalv1.1" -H "Content-Type: application/json" -H "Authorization: Bearer [ACCESS_TOKEN]"
curl https://api.stripe.com/v1/charges -u token_here:
Gardez le deux-points à la fin du jeton pour empêcher `cURL` de demander un mot de passe.
Le jeton est toujours au format suivant : `sk_live_24charshere`, où la partie `24charshere` contient 24 caractères parmi `a-z A-Z 0-9`. Il existe également une clé de test, qui commence par `sk_test`, mais cette clé est inutile car elle n'est utilisée qu'à des fins de test et ne contient probablement aucune information sensible. La clé live, en revanche, peut être utilisée pour extraire/récupérer beaucoup d'informations — allant des paiements à la liste complète des produits.
Gardez à l'esprit que vous ne pourrez jamais obtenir les informations complètes de la carte de crédit car Stripe ne vous donne que les 4 derniers chiffres.
Plus d'informations/documentation complète : https://stripe.com/docs/api/authentication.
## [Clé API Razorpay et clé secrète](https://razorpay.com/docs/api/)
Cela peut être vérifié en utilisant :```
curl -u <YOUR_KEY_ID>:<YOUR_KEY_SECRET> \
https://api.razorpay.com/v1/payments
curl https://circleci.com/api/v1.1/me?circle-token=
## [Clé API Cloudflare](https://api.cloudflare.com/#user-api-tokens-verify-token)```
curl -X GET "https://api.cloudflare.com/client/v4/user/tokens/verify" \
-H "Authorization: Bearer <YOUR_API_TOKEN>"
curl 'http://api.addressy.com/Capture/Interactive/Find/v1.00/json3.ws?Key=<KEY_HERE>&Countries=US,CA&Language=en&Limit=5&Text=BHAR'
## [Clé API Ipstack](https://ipstack.com/documentation)```
curl 'https://api.ipstack.com/{ip_address}?access_key={keyhere}'
Vous pouvez vérifier le jeton NPM en utilisant npm (en remplaçant 00000000-0000-0000-0000-000000000000 par le jeton NPM) :```
export NPM_TOKEN="00000000-0000-0000-0000-000000000000"
echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > .npmrc
npm whoami
Une autre façon de vérifier le token est d'interroger directement l'API :```
curl -H 'authorization: Bearer 00000000-0000-0000-0000-000000000000' 'https://registry.npmjs.org/-/whoami'
Vous obtiendrez le nom d'utilisateur en réponse en cas de succès, 401 Unauthorized si le jeton n'existe pas et 403 Forbidden si votre adresse IP n'est pas whitelistée.
Le jeton NPM peut être CIDR-whitelisted. Ainsi, si vous utilisez un jeton depuis un CIDR non-whitelisted, vous obtiendrez 403 Forbidden en réponse. Essayez donc de vérifier le jeton NPM depuis différentes plages IP !
P.S. Certaines entreprises utilisent des registres autres que registry.npmjs.org. Si c'est le cas, remplacez toutes les occurrences de registry.npmjs.org par le nom de domaine du registre NPM de l'entreprise.
curl https://api.opsgenie.com/v2/alerts -H 'Authorization: GenieKey API_KEY'
## [Keen.io API Key](https://keen.io/docs/api/)
Obtenir toutes les collections pour un projet spécifique :```
curl "https://api.keen.io/3.0/projects/PROJECT_ID/events?api_key=READ_KEY"
Note : Gardez le deux-points à la fin du jeton pour éviter que cURL ne demande un mot de passe. Info : Le jeton a toujours le format suivant : sk_live_34charshere, où la partie 34charshere contient 34 caractères parmi a-z A-Z 0-9. Il existe aussi une clé de test, qui commence par sk_test, mais cette clé est inutile car elle est uniquement utilisée à des fins de test et ne contient probablement aucune information sensible. La clé live, en revanche, peut être utilisée pour extraire/récupérer beaucoup d'informations. Des frais à la liste complète des produits. Gardez à l'esprit que vous ne pourrez jamais obtenir les informations complètes de la carte de crédit, car Stripe ne donne que les 4 derniers chiffres. Plus d'informations / documentation complète : https://stripe.com/docs/api/authentication =======
Obtenir les informations utilisateur :```` curl --header "X-TOKEN: <your_token>" https://calendly.com/api/v1/users/me
Lister les abonnements aux webhooks :````
curl --header "X-TOKEN: <your_token>" https://calendly.com/api/v1/hooks
Obtenez le nombre total de requêtes effectuées au cours des dernières 24 heures :``` curl -H "x-api-key: {API_Key}" "https://api.applicationinsights.io/v1/apps/{APP_ID}/metrics/requests/count"
## [Clé d'enregistrement Cypress](https://docs.cypress.io/guides/dashboard/projects.html#Record-key)
Afin de vérifier la validité de `recordKey`, vous aurez besoin de `projectId`, une valeur publique que l'on trouve généralement dans le fichier `cypress.json`. Remplacez `{recordKey}` et `{projectId}` dans le corps JSON par vos valeurs.```
curl -i -s -k -X $'POST' \
-H $'x-route-version: 4' -H $'x-os-name: darwin' -H $'x-cypress-version: 5.5.0' -H $'host: api.cypress.io' -H $'accept: application/json' -H $'content-type: application/json' -H $'Content-Length: 1433' -H $'Connection: close' \
--data-binary $'{\"ci\":{\"params\":null,\"provider\":null},\"specs\":[\"cypress/integration/examples/actions.spec.js\",\"cypress/integration/examples/aliasing.spec.js\",\"cypress/integration/examples/assertions.spec.js\",\"cypress/integration/examples/connectors.spec.js\",\"cypress/integration/examples/cookies.spec.js\",\"cypress/integration/examples/cypress_api.spec.js\",\"cypress/integration/examples/files.spec.js\",\"cypress/integration/examples/local_storage.spec.js\",\"cypress/integration/examples/location.spec.js\",\"cypress/integration/examples/misc.spec.js\",\"cypress/integration/examples/navigation.spec.js\",\"cypress/integration/examples/network_requests.spec.js\",\"cypress/integration/examples/querying.spec.js\",\"cypress/integration/examples/spies_stubs_clocks.spec.js\",\"cypress/integration/examples/traversal.spec.js\",\"cypress/integration/examples/utilities.spec.js\",\"cypress/integration/examples/viewport.spec.js\",\"cypress/integration/examples/waiting.spec.js\",\"cypress/integration/examples/window.spec.js\"],\"commit\":{\"sha\":null,\"branch\":null,\"authorName\":null,\"authorEmail\":null,\"message\":null,\"remoteOrigin\":null,\"defaultBranch\":null},\"group\":null,\"platform\":{\"osCpus\":[],\"osName\":\"darwin\",\"osMemory\":{\"free\":1153744896,\"total\":17179869184},\"osVersion\":\"19.6.0\",\"browserName\":\"Electron\",\"browserVersion\":\"85.0.4183.121\"},\"parallel\":null,\"ciBuildId\":null,\"projectId\":\"{projectId}\",\"recordKey\":\"{recordKey}\",\"specPattern\":null,\"tags\":[\"\"]}' \
$'https://api.cypress.io/runs'
Oui, cette requête doit être aussi volumineuse. Elle retournera 200 OK avec quelques informations sur l'exécution si projectId et recordKey sont valides, 404 Not Found avec {"message":"Project not found. Invalid projectId."} si projectId est invalide ou 401 Unauthorized avec {"message":"Invalid Record Key."} si recordKey est invalide.
Exemple de projectId est 1yxykz et exemple de recordKey est a216e7b4-4819-4713-b9c2-c5da60a1c48c.
Récupérer les détails du contenu d'une chaîne YouTube (le channelId dans ce cas pointe vers la chaîne de PewDiePie).``` curl -iLk 'https://www.googleapis.com/youtube/v3/activities?part=contentDetails&maxResults=25&channelId=UC-lHJZR3Gqxm24_Vd_AJ5Yw&key={KEY_HERE}'
## [Clé API ABTasty](https://developers.abtasty.com/server-side.html#authentication)```
curl "api_endpoint_here" -H "x-api-key: your_api_key"
Exporter les données d'analyse de campagne au format JSON, une entrée par ligne. L'utilisation de 'range' ou de 'startDateTime' et 'endDateTime' est requise.``` curl -H "Api_Key: {API_KEY}" https://api.iterable.com/api/export/data.json?dataTypeName=emailSend&range=Today&onlyFields=List.empty
## [Clés API Amplitude](https://help.amplitude.com/hc/en-us/articles/205406637-Export-API-Export-Your-Project-s-Event-Data)
La réponse est une archive compressée de fichiers JSON, avec potentiellement plusieurs fichiers par heure. Notez que les événements antérieurs au 2014-11-12 seront regroupés par jour au lieu de par heure. Si vous demandez des données pour une plage de temps pendant laquelle aucune donnée n'a été collectée pour le projet, vous recevrez une réponse 404 du serveur.```
curl -u API_Key:Secret_Key 'https://amplitude.com/api/2/export?start=20200201T5&end=20210203T20' >> yourfilename.zip
2. Récupérez les informations de build de la dernière application pour un projet spécifique :
> Utilisez le `name` et `owner.name` obtenus dans la réponse à l'Étape [1](#438). ```
curl -sX GET "https://api.appcenter.ms/v0.1/apps/{owner.name}/{name}/releases/latest" \
-H "Content-Type: application/json" \
-H "X-Api-Token: {your_api_token}"
curl -X POST
'https://api.weglot.com/translate?api_key=my_api_key'
-H 'Content-Type: application/json'
-d '{
"l_from":"en",
"l_to":"fr",
"request_url":"https://www.website.com/",
"words":[
{"w":"This is a blue car", "t": 1},
{"w":"This is a black car", "t": 1}
]
}'
## [Jeton API PivotalTracker](https://www.pivotaltracker.com/help/api/#top)
1. Lister les informations utilisateur avec le jeton API : ```
curl -X GET -H "X-TrackerToken: $TOKEN" "https://www.pivotaltracker.com/services/v5/me?fields=%3Adefault"
Une demande de jeton d'accès réussie renvoie un objet JSON contenant access_token, expires_in.``` curl -XPOST -H "Content-type: application/x-www-form-urlencoded" -d 'grant_type=client_credentials&client_id=&client_secret=' 'https://www.linkedin.com/oauth/v2/accessToken'
## [Help Scout OAUTH](https://developer.helpscout.com/mailbox-api/overview/authentication/)
Une requête de jeton d'accès réussie renvoie un objet JSON contenant token_type, access_token, expires_in.```
curl -X POST https://api.helpscout.net/v2/oauth2/token \
--data "grant_type=client_credentials" \
--data "client_id={application_id}" \
--data "client_secret={application_secret}"
curl "https://api.shodan.io/shodan/host/8.8.8.8?key=TOKEN_HERE"
## [Bazaarvoice Passkey](https://developer.bazaarvoice.com/conversations-api/home)
Une requête Passkey réussie retourne un objet JSON contenant le nom de l'entreprise.```
curl 'https://which-cpv-api.bazaarvoice.com/clientInfo?conversationspasskey=<Passkey>' --insecure
L'API Grafana prend en charge les schémas d'autorisation Bearer et Basic. Bearer :``` curl -s -H "Authorization: Bearer your-api-key" http://your-grafana-server-url.com/api/user
De base:```
curl -u username:password http://your-grafana-server-url.com/api/user
Je reçois avec plaisir les contributions du public.
Le système de suivi des problèmes est le canal privilégié pour les signalements de bugs et les demandes de fonctionnalités.
Le système de suivi des bugs utilise plusieurs étiquettes pour aider à organiser et identifier les problèmes.
Utilisez la recherche de problèmes GitHub — vérifiez si le problème a déjà été signalé.
Ce projet est réalisé uniquement à des fins éducatives et de tests éthiques. L'utilisation de cet outil pour attaquer des cibles sans consentement mutuel préalable est illégale. Les développeurs déclinent toute responsabilité et ne sont pas responsables des mauvais usages ou des dommages causés par cet outil.
| Nom | Point d'accès | Tarification |
|---|