streaak/keyhacksRaccolta curata di comandi per validare chiavi API trapelate da programmi bug bounty e test di penetrazione, che copre oltre 80 servizi tra cui AWS, GitHub, Slack e Twilio.
KeyHacks mostra metodi per validare diverse chiavi API trovate in un programma Bug Bounty o in un test di penetrazione.
@Gwen001 ha scriptato l'intero processo disponibile qui e può essere trovato qui
Se il comando seguente restituisce missing_text_or_fallback_or_attachments, significa che l'URL è valido, qualsiasi altra risposta significa che l'URL non è valido.```
curl -s -X POST -H "Content-type: application/json" -d '{"text":""}' "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX"
## [Token API Slack](https://api.slack.com/web)```
curl -sX POST "https://slack.com/api/auth.test?token=xoxp-TOKEN_HERE&pretty=1"
o``` curl -sX POST "https://slack.com/api/auth.test" -H "Accept: application/json; charset=utf-8" -H "Authorization: Bearer xoxb-TOKEN_HERE"
## [Nome utente e chiave di accesso SauceLabs](https://wiki.saucelabs.com/display/DOCS/Account+Methods)```
curl -u USERNAME:ACCESS_KEY https://saucelabs.com/rest/v1/users/USERNAME
Puoi generare token di accesso visitando l'URL qui sotto.``` https://graph.facebook.com/oauth/access_token?client_id=ID_HERE&client_secret=SECRET_HERE&redirect_uri=&grant_type=client_credentials
## Token di Accesso Facebook```
https://developers.facebook.com/tools/debug/accesstoken/?access_token=ACCESS_TOKEN_HERE&version=v3.2
Richiede un custom token, e una API key.
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:"
## [ID client e segreto client di Github](https://developer.github.com/v3/#oauth2-keysecret)```
curl 'https://api.github.com/users/whatever?client_id=xxxx&client_secret=yyyy'
Riferimento: 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"]}'
## Chiave privata SSH di GitHub
Le chiavi private SSH possono essere testate su github.com per verificare se sono registrate su un account utente esistente. Se la chiave esiste, verrà fornito il nome utente corrispondente alla chiave. ([fonte](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
## [Segreto dell'API di 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)
Ottieni tutti i proprietari:```
https://api.hubapi.com/owners/v2/owners?hapikey={keyhere}
Ottieni tutti i dettagli di contatto:``` https://api.hubapi.com/contacts/v1/lists/all/contacts/all?hapikey={keyhere}
## [Chiave 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
## [Token di accesso 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'
## [SendGrid API Token](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"
Rilevamento:
ID app/secret client: sq0[a-z]{3}-[0-9A-Za-z\-_]{22,43}
Token di autenticazione: EAAA[a-zA-Z0-9]{60}
ID app e secret client di test:``` 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]"
Risposta che indica credenziali valide:```
empty
Risposta che indica credenziali non valide:``` { "message": "Not Authorized", "type": "service.not_authorized" }
**Token di test Auth:**```
curl https://connect.squareup.com/v2/locations -H "Authorization: Bearer [AUHT_TOKEN]"
Risposta che indica credenziali valide:``` {"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"........
Risposta che indica credenziali non valide:```
{"errors":[{"category":"AUTHENTICATION_ERROR","code":"UNAUTHORIZED","detail":"This request could not be authorized."}]}
## [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"
Installa awscli, imposta l'ID e chiave segreta di accesso come variabili d'ambiente ed esegui il comando seguente:``` AWS_ACCESS_KEY_ID=xxxx AWS_SECRET_ACCESS_KEY=yyyy aws sts get-caller-identity
Le autorizzazioni delle credenziali AWS possono essere determinate utilizzando [Enumerate-IAM](https://github.com/andresriancho/enumerate-iam). Questo offre una visione più ampia dei privilegi delle credenziali AWS scoperte anziché limitarsi a controllare i bucket 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]'
## [Chiave privata 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.
## [JumpCloud Chiave API](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}'
## Microsoft Azure Tenant
Formato:```
CLIENT_ID: [0-9a-z\-]{36}
CLIENT_SECRET: [0-9A-Za-z\+\=]{40,50}
TENANT_ID: [0-9a-z\-]{36}
Verifica:``` 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 Shared Access Signatures (SAS)](https://github.com/MicrosoftDocs/azure-docs/blob/master/articles/storage/common/storage-dotnet-shared-access-signature-part-1.md)
Il seguente PowerShell può essere usato per testare un token Shared Access Signature:```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);
}
Se il comando sottostante restituisce Summary or Text is required., significa che l'URL è valido. Se restituisce Invalid webhook URL o qualsiasi altra risposta, significa che l'URL non è valido.```
curl -H "Content-Type:application/json" -d "{'text':''}" "YOUR_WEBHOOK_URL"
## [New Relic Personal API Key (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
Se valida, verifica ulteriormente se è una [chiave admin](https://docs.newrelic.com/docs/apis/get-started/intro-apis/types-new-relic-api-keys#admin)
## [Chiave API di 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"
Le chiavi segrete Mapbox iniziano con sk, le altre iniziano con pk (token pubblico), sk (token segreto) o tk (token temporaneo).```
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"
## [Chiave 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'
Se la chiave ha il permesso listIndexes, puoi elencare gli indici con:```
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: '
Altrimenti dovrai conoscere il nome di un indice (controlla il codice sorgente dell'app o le richieste che effettua). Quindi per enumerarne il contenuto:```
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>'
Sii cauto nell'eseguire questo comando, poiché il payload potrebbe essere eseguito in un ambiente amministrativo, a seconda dell'indice di cui stai modificando il highlightPreTag. Si consiglia di utilizzare un payload più silenzioso (come XSS Hunter) per dimostrare il possibile attacco di cross-site scripting.```
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": ""}'
## [Token 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"
## [BrowserStack Access Key](https://www.browserstack.com/automate/rest-api)```
curl -u "USERNAME:ACCESS_KEY" https://api.browserstack.com/automate/plan.json
Le restrizioni delle chiavi sono impostate per servizio. Quando testi la chiave, se la chiave è limitata/inattiva su un servizio, prova con un altro.
*I prezzi sono in USD per 1000 richieste (per le prime 100.000 richieste)
Ulteriori informazioni disponibili qui-
Invia una POST al seguente URL:``` https://www.google.com/recaptcha/api/siteverify
`secret` e `response` sono due parametri POST obbligatori, dove `secret` è la chiave e `response` è la risposta da testare.
Espressione regolare: `^6[0-9a-zA-Z_-]{39}$`. La chiave API inizia sempre con un 6 ed è lunga 40 caratteri. Leggi di più qui: https://developers.google.com/recaptcha/docs/verify.
## [Credenziali dell'account di servizio Google Cloud](https://cloud.google.com/docs/authentication/production)
Le credenziali dell'account di servizio possono essere trovate in un file JSON come questo:```
$ 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/..."
}
Se questo è il tuo caso, puoi verificare queste credenziali utilizzando lo strumento gcloud (come installare gcloud):```
$ gcloud auth activate-service-account --key-file=service_account.json
Activated service account credentials for: [...]
$ gcloud auth print-access-token
ya29.c...
In caso di successo vedrai il token di accesso stampato nel terminale. Tieni presente che dopo aver verificato che le credenziali sono effettivamente valide, potresti voler enumerare i permessi di queste credenziali, il che è un'altra storia.
## [Branch.IO Key and Secret](https://docs.branch.io/pages/apps/deep-linking-api/#app-read)
Visita il seguente URL per verificarne la validità:```
https://api2.branch.io/v1/app/KEY_HERE?branch_secret=SECRET_HERE
Visita questo link per verificare la validità della chiave. La risposta di una chiave valida dovrebbe iniziare con `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 di accesso Bit.ly](https://dev.bitly.com/authentication.html)
Visita il seguente URL per verificarne 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
## [Token di accesso 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"
I token API sono diversi dai token OAuth, i token API sono password generate automaticamente nell'interfaccia di amministrazione di Support.``` curl https://{target}.zendesk.com/api/v2/users.json \ -u support@{target}.com/token:{here your token}
## [Chiave API di 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
Questo problema può essere ulteriormente sfruttato controllando il gist di @hateshape https://gist.github.com/hateshape/2e671ea71d7c243fac7ebf51fb738f0a.``` curl "https://api.wpengine.com/1.2/?method=site&account_name=ACCOUNT_NAME&wpe_apikey=WPENGINE_APIKEY"
## [DataDog API key](https://docs.datadoghq.com/api/)```
curl "https://api.datadoghq.com/api/v1/dashboard?api_key=<api_key>&application_key=<application_key>"
Non cancellare il : alla fine.```
curl https://api.delighted.com/v1/metrics.json
-H "Content-Type: application/json"
-u YOUR_DELIGHTED_API_KEY:
[Token API di 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
## [Chiave API di WakaTime](https://wakatime.com/developers)```
curl "https://wakatime.com/api/v1/users/current?api_key=KEY_HERE"
## [Token di accesso Spotify](https://developer.spotify.com/documentation/general/guides/authorization-guide/)```
curl -H "Authorization: Bearer <ACCESS_TOKEN>" https://api.spotify.com/v1/me
Es.: IGQVJ...``` curl -X GET 'https://graph.instagram.com/{user-id}?fields=id,username&access_token={access-token}'
## [Token di Accesso all'API Graph di Instagram](https://developers.facebook.com/docs/instagram-api/getting-started)
Ad es.: 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>"
## [Token di registrazione di GitLab Runner](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"
Il token di accesso può essere ulteriormente utilizzato per estrarre dati dall'API PayPal. Maggiori informazioni: https://developer.paypal.com/docs/api/overview/#make-rest-api-calls.
Questo può essere verificato utilizzando:```
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:
Mantieni i due punti alla fine del token per evitare che `cURL` richieda una password.
Il token è sempre nel seguente formato: `sk_live_24charshere`, dove la parte `24charshere` contiene 24 caratteri da `a-z A-Z 0-9`. Esiste anche una chiave di test, che inizia con `sk_test`, ma questa chiave è inutile poiché viene utilizzata solo per scopi di test e molto probabilmente non contiene informazioni sensibili. La chiave live, invece, può essere utilizzata per estrarre/recuperare molte informazioni — dalle transazioni all'elenco completo dei prodotti.
Tieni presente che non sarai mai in grado di ottenere l'intera informazione della carta di credito poiché Stripe fornisce solo le ultime 4 cifre.
Maggiori informazioni/documentazione completa: https://stripe.com/docs/api/authentication.
## [Chiave API e Chiave Segreta di Razorpay](https://razorpay.com/docs/api/)
Questo può essere verificato utilizzando:```
curl -u <YOUR_KEY_ID>:<YOUR_KEY_SECRET> \
https://api.razorpay.com/v1/payments
## [Cloudflare API key](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'
## [Ipstack API Key](https://ipstack.com/documentation)```
curl 'https://api.ipstack.com/{ip_address}?access_key={keyhere}'
È possibile verificare il token NPM usando npm (sostituendo 00000000-0000-0000-0000-000000000000 con il token NPM):```
export NPM_TOKEN="00000000-0000-0000-0000-000000000000"
echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > .npmrc
npm whoami
Un altro modo per verificare il token è interrogare direttamente l'API:```
curl -H 'authorization: Bearer 00000000-0000-0000-0000-000000000000' 'https://registry.npmjs.org/-/whoami'
Riceverai il nome utente in risposta in caso di successo, 401 Unauthorized se il token non esiste e 403 Forbidden se il tuo indirizzo IP non è nella whitelist.
Il token NPM può essere CIDR-whitelisted. Quindi se stai usando un token da un CIDR non autorizzato riceverai 403 Forbidden in risposta. Prova quindi a verificare il token NPM da diversi intervalli IP!.
P.S. Alcune aziende utilizzano registry diversi da registry.npmjs.org. In tal caso, sostituisci tutte le occorrenze di registry.npmjs.org con il nome di dominio del registry NPM dell'azienda.
curl https://api.opsgenie.com/v2/alerts -H 'Authorization: GenieKey API_KEY'
## [Keen.io API Key](https://keen.io/docs/api/)
Ottieni tutte le raccolte per un progetto specifico:```
curl "https://api.keen.io/3.0/projects/PROJECT_ID/events?api_key=READ_KEY"
Nota: Mantieni i due punti alla fine del token per evitare che cURL richieda una password. Info: Il token è sempre nel seguente formato: sk_live_34charshere, dove la parte 34charshere contiene 34 caratteri da a-z A-Z 0-9 Esiste anche una chiave di test, che inizia con sk_test, ma questa chiave è inutile poiché viene utilizzata solo per scopi di test e molto probabilmente non contiene informazioni sensibili. La chiave live, d'altra parte, può essere utilizzata per estrarre/recuperare molte informazioni. Dalle transazioni all'elenco completo dei prodotti. Tieni presente che non sarai mai in grado di ottenere l'intera informazione della carta di credito poiché Stripe fornisce solo le ultime 4 cifre. Maggiori informazioni / documentazione completa: https://stripe.com/docs/api/authentication =======
Ottieni informazioni sull'utente:```` curl --header "X-TOKEN: <your_token>" https://calendly.com/api/v1/users/me
Elenco abbonamenti webhook:````
curl --header "X-TOKEN: <your_token>" https://calendly.com/api/v1/hooks
Ottieni il numero totale di richieste effettuate nelle ultime 24 ore:``` curl -H "x-api-key: {API_Key}" "https://api.applicationinsights.io/v1/apps/{APP_ID}/metrics/requests/count"
## [Cypress record key](https://docs.cypress.io/guides/dashboard/projects.html#Record-key)
Per verificare la validità di `recordKey` avrai bisogno di `projectId`, che è un valore pubblico solitamente reperibile nel file `cypress.json`. Sostituisci `{recordKey}` e `{projectId}` nel corpo JSON con i tuoi valori.```
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'
Sì, questa richiesta deve essere così grande. Restituirà 200 OK con alcune informazioni sull'esecuzione nel caso in cui sia projectId che recordKey siano validi, 404 Not Found con {"message":"Project not found. Invalid projectId."} se projectId non è valido o 401 Unauthorized con {"message":"Invalid Record Key."} se recordKey non è valido.
Esempio di projectId è 1yxykz e esempio di recordKey è a216e7b4-4819-4713-b9c2-c5da60a1c48c.
Recupera i dettagli del contenuto per un canale YouTube (il channelId in questo caso punta al canale di PewDiePie).``` curl -iLk 'https://www.googleapis.com/youtube/v3/activities?part=contentDetails&maxResults=25&channelId=UC-lHJZR3Gqxm24_Vd_AJ5Yw&key={KEY_HERE}'
## [Chiave API ABTasty](https://developers.abtasty.com/server-side.html#authentication)```
curl "api_endpoint_here" -H "x-api-key: your_api_key"
Esporta i dati analitici delle campagne in formato JSON, una voce per riga. È richiesto l'uso di 'range' o 'startDateTime' e 'endDateTime'.``` curl -H "Api_Key: {API_KEY}" https://api.iterable.com/api/export/data.json?dataTypeName=emailSend&range=Today&onlyFields=List.empty
## [Chiavi API di Amplitude](https://help.amplitude.com/hc/en-us/articles/205406637-Export-API-Export-Your-Project-s-Event-Data)
La risposta è un archivio zip di file JSON, con potenzialmente più file per ora. Nota che gli eventi precedenti al 2014-11-12 saranno raggruppati per giorno invece che per ora. Se richiedi dati per un intervallo di tempo durante il quale non sono stati raccolti dati per il progetto, riceverai una risposta 404 dal server.```
curl -u API_Key:Secret_Key 'https://amplitude.com/api/2/export?start=20200201T5&end=20210203T20' >> yourfilename.zip
2. Recupera le ultime informazioni sulla build dell'app per un progetto specifico:
> Utilizza `name` e `owner.name` ottenuti nella risposta al Passo [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}
]
}'
## [Token API di PivotalTracker](https://www.pivotaltracker.com/help/api/#top)
1. List User Information with API Token: ```
curl -X GET -H "X-TrackerToken: $TOKEN" "https://www.pivotaltracker.com/services/v5/me?fields=%3Adefault"
Una richiesta di token di accesso riuscita restituisce un oggetto JSON contenente 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/)
Una richiesta di access token riuscita restituisce un oggetto JSON contenente 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}"
## [Bazaarvoice Passkey](https://developer.bazaarvoice.com/conversations-api/home)
Una richiesta Passkey riuscita restituisce un oggetto JSON contenente il nome dell'azienda.```
curl 'https://which-cpv-api.bazaarvoice.com/clientInfo?conversationspasskey=<Passkey>' --insecure
L'API di Grafana supporta gli schemi di autorizzazione Bearer e Basic. Bearer:``` curl -s -H "Authorization: Bearer your-api-key" http://your-grafana-server-url.com/api/user
Base:```
curl -u username:password http://your-grafana-server-url.com/api/user
Accolgo contributi dal pubblico.
Il tracker delle issue è il canale preferito per segnalazioni di bug e richieste di funzionalità.
Il tracker dei bug utilizza diverse etichette per organizzare e identificare le issue.
Utilizza la ricerca delle issue su GitHub — verifica se l'issue è già stata segnalata.
Questo progetto è realizzato esclusivamente a scopo educativo e di test etico. L'utilizzo di questo strumento per attaccare bersagli senza previo consenso reciproco è illegale. Gli sviluppatori non si assumono alcuna responsabilità e non sono responsabili per qualsiasi uso improprio o danno causato da questo strumento.
| Varies |
| Completamento automatico | https://maps.googleapis.com/maps/api/place/autocomplete/json?input=Bingh&types=%28cities%29&key=KEY_HERE | Varies |
| Altitudine | https://maps.googleapis.com/maps/api/elevation/json?locations=39.7391536,-104.9847034&key=KEY_HERE | $5 |
| Fuso orario | https://maps.googleapis.com/maps/api/timezone/json?location=39.6034810,-119.6822510×tamp=1331161200&key=KEY_HERE | $5 |
| Strade | https://roads.googleapis.com/v1/nearestRoads?points=60.170880,24.942795\|60.170879,24.942796\|60.170877,24.942796&key=KEY_HERE | $10 |
| Geolocalizzazione | https://www.googleapis.com/geolocation/v1/geolocate?key=KEY_HERE | $5 |