diff --git a/fixtures/vcr_cassettes/create_report.yml b/fixtures/vcr_cassettes/create_report.yml index c4d80cb..4f01cbc 100644 --- a/fixtures/vcr_cassettes/create_report.yml +++ b/fixtures/vcr_cassettes/create_report.yml @@ -8,74 +8,26 @@ http_interactions: string: '{"data":{"type":"report","attributes":{"team_handle":"github","title":"hi","vulnerability_information":"hi","impact":"string","severity_rating":"none","source":"api"}}}' headers: Authorization: - - Basic NOPE - User-Agent: - - Faraday v1.0.1 + - Basic Zm9vOmJhcg== Content-Type: - application/json - Accept-Encoding: - - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 - Accept: - - "*/*" + User-Agent: + - Faraday v1.0.1 response: status: code: 201 message: Created headers: Date: - - Wed, 06 May 2020 23:02:54 GMT + - Wed, 07 Feb 2024 12:00:00 GMT Content-Type: - application/json; charset=utf-8 Transfer-Encoding: - chunked Connection: - keep-alive - Set-Cookie: - - __cfduid=d31f31bc632e337f7fa240d7a863f92a01588806173; expires=Fri, 05-Jun-20 - 23:02:53 GMT; path=/; Domain=api.hackerone.com; HttpOnly; SameSite=Lax; Secure - X-Request-Id: - - 55676c0a-2510-4787-9e47-7f74c1e9b2ac - Etag: - - W/"1f8bd995ef79550e2f8c8484301fadcc" - Cache-Control: - - max-age=0, private, must-revalidate - Strict-Transport-Security: - - max-age=31536000; includeSubDomains; preload - X-Frame-Options: - - DENY - X-Content-Type-Options: - - nosniff - X-Xss-Protection: - - 1; mode=block - X-Download-Options: - - noopen - X-Permitted-Cross-Domain-Policies: - - none - Referrer-Policy: - - strict-origin-when-cross-origin - Expect-Ct: - - enforce, max-age=86400 - Content-Security-Policy: - - 'default-src ''none''; base-uri ''self''; block-all-mixed-content; child-src - www.youtube-nocookie.com; connect-src ''self'' www.google-analytics.com errors.hackerone.net; - font-src ''self''; form-action ''self''; frame-ancestors ''none''; img-src - ''self'' data: cover-photos.hackerone-user-content.com hackathon-photos.hackerone-user-content.com - profile-photos.hackerone-user-content.com hackerone-us-west-2-production-attachments.s3.us-west-2.amazonaws.com; - media-src ''self'' hackerone-us-west-2-production-attachments.s3.us-west-2.amazonaws.com; - script-src ''self'' www.google-analytics.com; style-src ''self'' ''unsafe-inline''; - report-uri https://errors.hackerone.net/api/30/csp-report/?sentry_key=61c1e2f50d21487c97a071737701f598' - Cf-Cache-Status: - - DYNAMIC - Server: - - cloudflare - Cf-Ray: - - 58f654d83ea1bc9c-SEA - Cf-Request-Id: - - '028dd35b1e0000bc9c75365200000001' body: - encoding: ASCII-8BIT - string: !binary |- - {"data":{"id":"867479","type":"report","attributes":{"title":"hi","state":"new","created_at":"2020-05-06T23:02:53.615Z","vulnerability_information":"hi\n\n## Impact\n\nstring","triaged_at":null,"closed_at":null,"last_reporter_activity_at":"2020-05-06T23:02:53.679Z","first_program_activity_at":"2020-05-06T23:02:53.679Z","last_program_activity_at":"2020-05-06T23:02:53.679Z","bounty_awarded_at":null,"swag_awarded_at":null,"disclosed_at":null,"reporter_agreed_on_going_public_at":null,"last_public_activity_at":"2020-05-06T23:02:53.679Z","last_activity_at":"2020-05-06T23:02:53.679Z","cve_ids":[],"source":"api"},"relationships":{"reporter":{"data":{"id":"1013596","type":"user","attributes":{"username":"rzhade3-tester","name":null,"disabled":false,"created_at":"2020-03-30T15:21:10.873Z","profile_picture":{"62x62":"/assets/avatars/default-71a302d706457f3d3a31eb30fa3e73e6cf0b1d677b8fa218eaeaffd67ae97918.png","82x82":"/assets/avatars/default-71a302d706457f3d3a31eb30fa3e73e6cf0b1d677b8fa218eaeaffd67ae97918.png","110x110":"/assets/avatars/default-71a302d706457f3d3a31eb30fa3e73e6cf0b1d677b8fa218eaeaffd67ae97918.png","260x260":"/assets/avatars/default-71a302d706457f3d3a31eb30fa3e73e6cf0b1d677b8fa218eaeaffd67ae97918.png"},"bio":null,"website":null,"location":null,"hackerone_triager":false}}},"program":{"data":{"id":"11767","type":"program","attributes":{"handle":"github-test","policy":"# GitHub Security Bug Bounty\n\nSoftware security researchers are increasingly engaging with Internet companies to hunt down vulnerabilities. Our bounty program gives a tip of the hat to these researchers and provides rewards of  $30,000 or more for critical vulnerabilities.\n\n\nYou can find more information in our [rules](https://bounty.github.com/#rules), [scope](https://bounty.github.com/#scope), [targets](https://bounty.github.com/#targets), and [FAQ](https://bounty.github.com/#faqs) sections. You can also check the current rankings on the [leaderboard](https://bounty.github.com/#leaderboard).\n\nHappy hacking!\n\n\n## Rules\n\n### Before you start\n\n* Check the list of bugs that have been [classified as ineligible](https://bounty.github.com/ineligible.html). Submissions which are ineligible will likely be closed as `Not Applicable`.\n* Check the [GitHub Changelog](https://github.blog/changelog/) for recently launched features.\n* Never attempt non-technical attacks such as social engineering, phishing, or physical attacks against our employees, users, or infrastructure.\n* When in doubt, contact us at `bounty@github.com`.\n* By participating in GitHub's Bug Bounty program (the \"Program\"), you acknowledge that you have read and agree to GitHub's [Terms of Service](https://help.github.com/articles/github-terms-of-service) as well as the following:\n\n  * you're not participating from a country against which the United States has issued export sanctions or other trade restrictions, including Cuba, Iran, North Korea, Sudan, and Syria.\n\n  * your participation in the Program will not violate any law applicable to you, or disrupt or compromise any data that is not your own.\n\n  * you are solely responsible for any applicable taxes, withholding or otherwise, arising from or relating to your participation in the Program, including from any bounty payments.\n\n  * GitHub reserves the right to terminate or discontinue the Program at its discretion.\n\n  * Only test for vulnerabilities on sites you know to be operated by GitHub and are [in-scope](https://bounty.github.com#scope). Some sites hosted on subdomains of `GitHub.com` are operated by third parties and should not be tested.\n\n\n### Legal safe harbor\n\nYour research is covered by the [GitHub Bug Bounty Program Legal Safe Harbor](https://help.github.com/articles/github-bug-bounty-program-legal-safe-harbor/) policy. In summary:\n* We consider security research and vulnerability disclosure activities conducted consistent with this policy as “authorized” conduct under the Computer Fraud and Abuse Act, the DMCA, and other applicable computer use laws such as Cal. Penal Code 502(c). We waive any potential DMCA claim against you for circumventing the technological measures we have used to protect the applications in this bug bounty program's scope.\n* We want you to responsibly disclose through our bug bounty program, and don't want researchers put in fear of legal consequences because of their good faith attempts to comply with our bug bounty policy. We cannot bind any third party, so do not assume this protection extends to any third party. If in doubt, ask us before engaging in any specific action you think might go outside the bounds of our policy.\n* Because both identifying and non-identifying information can put a researcher at risk, we limit what we share with third parties. We may provide non-identifying substantive information from your report to an affected third party, but only after notifying you and receiving a commitment that the third party will not pursue legal action against you. We will only share identifying information (name, email address, phone number, etc.) with a third party if you give your written permission.\n* If your security research as part of the bug bounty program violates certain restrictions in our site policies, the safe harbor terms permit a limited exemption.\n\n\n### Performing your research\n\n* Do not impact other users with your testing, this includes testing vulnerabilities in repositories or organizations you do not own. If you are attempting to find an authorization bypass, you must use accounts you own.\n* The following are **never** allowed and are ineligible for reward. We may suspend your GitHub account and ban your IP address for:\n\n  * Performing distributed denial of service (DDoS) or other volumetric attacks\n  * Spamming content\n  * Large-scale vulnerability scanners, scrapers, or automated tools which produce excessive amounts of traffic.\n    * Note: We _do_ allow the use of automated tools so long as they do not produce excessive amounts of traffic. For example, running one `nmap` scan against one host is allowed, but sending 65,000 requests in two minutes using Burp Suite Intruder is excessive.\n* Researching denial-of-service attacks is allowed and eligible for rewards only if you follow these rules:\n\n  * Research **must** be performed in organizations or repositories you own\n  * Stop **immediately** if you believe you have affected the availability of our services. Don't worry about demonstrating the full impact of your vulnerability, GitHub's security team will be able to determine the impact.\n  * There are no limits for researching denial of service vulnerabilities against your own instance of [GitHub Enterprise Server](https://bounty.github.com/targets/github-enterprise-server.html)\n\n\n### Handling personally identifiable information (PII)\n\n* Personally identifying information (PII) includes:\n  * legal and/or full names\n  * names or usernames combined with other identifiers like phone numbers or email addresses\n  * health or financial information (including insurance information, social security numbers, etc.)\n  * information about political or religious affiliations\n  * information about race, ethnicity, sexual orientation, gender, or other identifying information that could be used for discriminatory purposes\n* Do not intentionally access others' PII. If you suspect a service provides access to PII, limit queries to your own personal information.\n* Report the vulnerability *immediately* and do not attempt to access any other data. The GitHub Security team will assess the scope and impact of the PII exposure.\n* Limit the amount of data returned from services. For SQL injection, for example, limit the number of rows returned\n* You must delete all your local, stored, or cached copies of data containing PII as soon as possible. We may ask you to sign a certificate of deletion and confidentiality agreement regarding the exact information you accessed. This agreement will not affect your bounty reward.\n* We may ask you for the usernames and IP addresses used during your testing to assess the impact of the vulnerability\n\n\n### Reporting your vulnerability\n\n* Submissions must include written instructions for reproducing the vulnerability. Submissions without clear reproduction steps or which only include reproduction steps in video form may be ineligible for a reward.\n* When reporting vulnerabilities you must keep all information on HackerOne. Do not post information to video-sharing or pastebin sites. Videos and images can be uploaded directly via HackerOne.\n* For vulnerabilities involving personally identifiable information, please explain the kind of PII you believe is exposed and limit the amount of PII data included in your submissions. For textual information and screenshots, please only include redacted data in your submission.\n* Do not publicly disclose your submission until GitHub has evaluated the impact.\n\n\n### Receiving your award\n\n* All reward amounts are determined by our [severity guidelines](https://bounty.github.com/#severity-guidelines).\n* When duplicates occur, we only award the first report that was received (provided that it can be fully reproduced).\n* You are free to publish write-ups about your vulnerability and GitHub will not limit what you write. We may pay out your reward before the vulnerability is patched so we may ask that you delay publishing to keep other GitHub users safe.\n* Medium, high, and critical severity issues will be written up on the GitHub Bug Bounty site and included in our leaderboard. We don't currently post write-ups for low severity vulnerabilities.\n* GitHub is a CVE Numbering Authority (CNA) for GitHub Enterprise Server. Eligible Bug Bounty submissions that affect GitHub Enterprise Server may be assigned CVEs. These CVEs will be shared with submitters via HackerOne, included in [bounty write-ups](https://bounty.github.com/bounty-hunters.html) and listed in the GitHub Enterprise Server [release notes](https://enterprise.github.com/releases).\n* You may prefer the reward go toward helping others. If you choose to do so, GitHub will donate your reward to an established 501(c)(3) charitable organization of your choice. GitHub will also match your donation - subject to our discretion. Any rewards that go unclaimed after 12 months will be donated to a charity of GitHub's choosing.\n\n\n## Scope\n\nGitHub runs a number of services but only submissions under the following domains are eligible for rewards. Any GitHub-owned domains not listed below are *not* in-scope, *not* eligible for rewards and *not* covered by our [legal safe harbor](https://bounty.github.com#legal_safe_harbor).\n\n\n### github.com\n\nOur main domain hosting user-facing GitHub services.. All subdomains under `github.com` are in-scope *except*:\n* `blog.github.com`\n* `community.github.com`\n* `email.enterprise.github.com`\n* `email.finance.github.com`\n* `email.staging.finance.github.com`\n* `email.support.github.com`\n* `email.verify.github.com`\n* `google7650dcf6146f04d8.github.com`\n* `k1._domainkey.github.com`\n* `k1._domainkey.mcmail.github.com`\n* `mcmail.github.com`\n* `resources.github.com`\n* `*.resources.github.com`\n* `sgmail.github.com`\n* `*.sgmail.github.com`\n* `shop.github.com`\n* `smtp.github.com`\n* `*.smtp.github.com`\n* `support.github.com`\n\n### githubassets.com\n\nOur domain for hosting static assets.. All subdomains under `githubassets.com` are in-scope\n\n### githubusercontent.com\n\nOur domain for hosting and rendering users' data.. All subdomains under `githubusercontent.com` are in-scope\n\n### githubapp.com\n\nOur domain for hosting employee-facing services.. All subdomains under `githubapp.com` are in-scope *except*:\n* `atom-io.githubapp.com`\n* `atom-io-staging.githubapp.com`\n* `email.enterprise-staging.githubapp.com`\n* `email.haystack.githubapp.com`\n* `reply.githubapp.com`\n\n### github.net\n\nOur domain for hosting GitHub's internal production services. Many of these services are not accessible from outside our internal network.. All subdomains under `github.net` are in-scope\n\n### semmle.com\n\nOur main domain for Semmle and LGTM services. All subdomains under `semmle.com` are in-scope *except*:\n* `dev.semmle.com`\n* `git.semmle.com`\n* `jira.semmle.com`\n* `wiki.semmle.com`\n\n### semmle.net\n\nOur domain for non-production Semmle services. All subdomains under `semmle.net` are in-scope\n\n### downloads.lgtm.com\n\nOur domain for serving LGTM downloads.. All subdomains under `downloads.lgtm.com` are in-scope\n\n### lgtm-com.pentesting.semmle.net\n\nAn instance of [LGTM](https://bounty.github.com/targets/lgtm.html) especially for Bug Bounty research.. All subdomains under `lgtm-com.pentesting.semmle.net` are in-scope\n\n### backend-dot-lgtm-penetration-testing.appspot.com\n\nAn instance of [LGTM](https://bounty.github.com/targets/lgtm.html)'s backend used for triggering automated tasks.. All subdomains under `backend-dot-lgtm-penetration-testing.appspot.com` are in-scope\n\n## Severity Guidelines\n\nAll bounty submissions are rated by GitHub using a purposefully simple scale. Each vulnerability is unique but the following is a rough guideline we use internally for rating and rewarding submissions:\n\n\n### Critical: $20,000 - $30,000\n\nCritical severity issues present a direct and immediate risk to a broad array of our users or to GitHub itself. They often affect relatively low-level/foundational components in one of our application stacks or infrastructure. For example:\n* arbitrary code/command execution on a GitHub server in our production network.\n* arbitrary SQL queries on the GitHub production database.\n* bypassing the GitHub login process, either password or 2FA.\n* access to sensitive production user data or access to internal production systems.\n* accessing another user's data in the GitHub Actions service.\n\nThe upper bound for critical vulnerabilities, $30,000, is only a guideline and GitHub may reward higher amounts for exceptional reports.\n\n\n### High: $10,000 - $20,000\n\nHigh severity issues allow an attacker to read or modify highly sensitive data that they are not authorized to access. They are generally more narrow in scope than critical issues, though they may still grant an attacker extensive access. For example:\n* injecting attacker controlled content into GitHub.com (XSS) which bypasses CSP.\n* bypassing authorization logic to grant a repository collaborator more access than intended.\n* discovering sensitive user or GitHub data in a publicly exposed resource, such as an S3 bucket.\n* gaining access to a non-critical resource that only GitHub employees should be able to reach.\n* using the GitHub Actions repo-scoped GitHub token to access high-risk private content outside of that repository.\n* code execution in a desktop app that requires no user interaction.\n\n\n### Medium: $4,000 - $10,000\n\nMedium severity issues allow an attacker to read or modify limited amounts of data that they are not authorized to access. They generally grant access to less sensitive information than high severity issues. For example:\n* disclosing the title of issues in private repositories which should be be inaccessible.\n* injecting attacker controlled content into GitHub.com (XSS) but not bypassing CSP or executing sensitive actions with another user's session.\n* bypassing CSRF validation for low risk actions, such as starring a repository or unsubscribing from a mailing list.\n* escaping the LGTM worker sandbox to access other user's data or private networked resources\n\n\n### Low: $617 - $2,000\n\nLow severity issues allow an attacker to access extremely limited amounts of data. They may violate an expectation for how something is intended to work, but it allows nearly no escalation of privilege or ability to trigger unintended behavior by an attacker. For example:\n* signing up arbitrary users for access to an \"early access feature\" without their consent.\n* creating an issue comment that bypasses our image proxying filter by providing a malformed URL.\n* bypassing community-and-safety features such as locked conversations.\n* bypassing billing \u0026 plan restrictions to gain access to paid features.\n* triggering verbose or debug error pages without proof of exploitability or obtaining sensitive information.\n* triggering application exceptions that could affect many GitHub users.\n* triggering XSS or CSRF vulnerabilities in LGTM\n\n","created_at":"2016-04-15T17:10:31.261Z","updated_at":"2020-04-08T13:45:49.548Z"}}},"severity":{"data":{"id":"713568","type":"severity","attributes":{"rating":"none","author_type":"User","user_id":1013596,"created_at":"2020-05-06T23:02:53.634Z"}}},"swag":{"data":[]},"attachments":{"data":[]},"activities":{"data":[]},"bounties":{"data":[]},"summaries":{"data":[]},"custom_field_values":{"data":[]}}}} - http_version: null + encoding: UTF-8 + string: '{"data":{"id":"1337","type":"report","attributes":{"title":"hi","state":"new","created_at":"2024-02-07T12:00:00.000Z","vulnerability_information":"hi","triaged_at":null,"closed_at":null,"last_reporter_activity_at":"2024-02-07T12:00:00.000Z","first_program_activity_at":"2024-02-07T12:00:00.000Z","last_program_activity_at":"2024-02-07T12:00:00.000Z","bounty_awarded_at":null,"swag_awarded_at":null,"disclosed_at":null,"reporter_agreed_on_going_public_at":null,"last_public_activity_at":"2024-02-07T12:00:00.000Z","last_activity_at":"2024-02-07T12:00:00.000Z","source":"api"},"relationships":{"reporter":{"data":{"id":"12345","type":"user"}},"program":{"data":{"id":"54321","type":"program"}}}}}' recorded_at: Wed, 06 May 2020 23:02:53 GMT recorded_with: VCR 5.1.0 diff --git a/fixtures/vcr_cassettes/report.yml b/fixtures/vcr_cassettes/report.yml index 4a3bea1..cf8a6bd 100644 --- a/fixtures/vcr_cassettes/report.yml +++ b/fixtures/vcr_cassettes/report.yml @@ -8,7 +8,7 @@ http_interactions: string: '' headers: Authorization: - - Basic nope= + - Basic Zm9vOmJhcg== # This is base64 encoded of "foo:bar" User-Agent: - Faraday v0.11.0 Accept-Encoding: diff --git a/fixtures/vcr_cassettes/report_list.yml b/fixtures/vcr_cassettes/report_list.yml index 72486e3..f345a6f 100644 --- a/fixtures/vcr_cassettes/report_list.yml +++ b/fixtures/vcr_cassettes/report_list.yml @@ -8,13 +8,15 @@ http_interactions: string: '' headers: Authorization: - - Basic nope= + - Basic Zm9vOmJhcg== # This is base64 encoded "foo:bar" User-Agent: - - Faraday v0.11.0 - Accept-Encoding: - - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + - Faraday v1.0.1 + Content-Type: + - application/json Accept: - "*/*" + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 response: status: code: 200 diff --git a/lib/hackerone/client.rb b/lib/hackerone/client.rb index e0e41b4..2351ae4 100644 --- a/lib/hackerone/client.rb +++ b/lib/hackerone/client.rb @@ -34,7 +34,6 @@ class NotConfiguredError < StandardError; end DEFAULT_CRITICAL_RANGE = 5000...100_000_000 LENIENT_MODE_ENV_VARIABLE = "HACKERONE_CLIENT_LENIENT_MODE" - REPORT_STATES = %w( new triaged @@ -48,7 +47,7 @@ class NotConfiguredError < StandardError; end class << self ATTRS = [:low_range, :medium_range, :high_range, :critical_range].freeze - attr_accessor :program + attr_accessor :program, :token, :token_name attr_reader *ATTRS ATTRS.each do |attr| @@ -60,14 +59,28 @@ class << self end class Api - def initialize(program = nil) + def initialize(program = nil, token: nil, token_name: nil) @program = program + @token = token || ENV["HACKERONE_TOKEN"] + @token_name = token_name || ENV["HACKERONE_TOKEN_NAME"] + # Set class-level token and token_name if provided + if token + HackerOne::Client.token = token + end + + if token_name + HackerOne::Client.token_name = token_name + end end def program @program || HackerOne::Client.program end + def token_name + @token_name || ENV["HACKERONE_TOKEN_NAME"] + end + def reporters raise ArgumentError, "Program cannot be nil" unless program response = self.class.hackerone_api_connection.get do |req| @@ -200,12 +213,12 @@ def self.parse_response(response, extract_data: true) end def self.hackerone_api_connection - unless ENV["HACKERONE_TOKEN_NAME"] && ENV["HACKERONE_TOKEN"] - raise NotConfiguredError, "HACKERONE_TOKEN_NAME HACKERONE_TOKEN environment variables must be set" + unless HackerOne::Client.token_name && HackerOne::Client.token + raise NotConfiguredError, "Either set token_name and token or HACKERONE_TOKEN_NAME and HACKERONE_TOKEN environment variables" end @connection ||= Faraday.new(url: "https://api.hackerone.com/v1") do |faraday| - faraday.request(:authorization, :basic, ENV["HACKERONE_TOKEN_NAME"], ENV["HACKERONE_TOKEN"]) + faraday.request(:authorization, :basic, HackerOne::Client.token_name, HackerOne::Client.token) faraday.adapter Faraday.default_adapter end end diff --git a/spec/hackerone/client/asset_spec.rb b/spec/hackerone/client/asset_spec.rb index 32ca878..a3df8a1 100644 --- a/spec/hackerone/client/asset_spec.rb +++ b/spec/hackerone/client/asset_spec.rb @@ -1,13 +1,16 @@ # frozen_string_literal: true require "spec_helper" +require "webmock/rspec" RSpec.describe HackerOne::Client::Asset do - before(:all) do - ENV["HACKERONE_TOKEN_NAME"] = "foo" - ENV["HACKERONE_TOKEN"] = "bar" - end + let(:api) { HackerOne::Client::Api.new("github", token: "bar", token_name: "foo") } + before(:each) do + # Initialize the API client before running tests + api + + # Stub the HTTP request for fetching the program stub_request(:get, "https://api.hackerone.com/v1/programs/18969"). to_return(body: <<~JSON) { @@ -36,6 +39,7 @@ } JSON + # Stub the HTTP request for fetching the assets stub_request(:get, "https://api.hackerone.com/v1/organizations/14/assets?page%5Bnumber%5D=1&page%5Bsize%5D=100"). to_return(body: <<~JSON2) { @@ -114,17 +118,35 @@ "links": {} } JSON2 + + # Stub the HTTP request for fetching the user's programs + stub_request(:get, "https://api.hackerone.com/v1/me/programs"). + to_return(body: <<~JSON3) +{ + "data": [ + { + "id": "18969", + "type": "program", + "attributes": { + "handle": "github", + "created_at": "2016-02-02T04:05:06.000Z", + "updated_at": "2016-02-02T04:05:06.000Z" + } + } + ] +} + JSON3 end after(:each) do - # clear cached programs to prevent contaminatin between tests + # Clear both cached programs and configuration HackerOne::Client::Program.instance_variable_set(:@my_programs, nil) + HackerOne::Client.instance_variable_set(:@token, nil) + HackerOne::Client.instance_variable_set(:@token_name, nil) end let(:program) do - VCR.use_cassette(:programs) do - HackerOne::Client::Program.find("github") - end + HackerOne::Client::Program.find("github") end let(:organization) do diff --git a/spec/hackerone/client/program_spec.rb b/spec/hackerone/client/program_spec.rb index 529e19f..d04c04f 100644 --- a/spec/hackerone/client/program_spec.rb +++ b/spec/hackerone/client/program_spec.rb @@ -3,9 +3,18 @@ require "spec_helper" RSpec.describe HackerOne::Client::Program do - before(:all) do - ENV["HACKERONE_TOKEN_NAME"] = "foo" - ENV["HACKERONE_TOKEN"] = "bar" + let(:api) { HackerOne::Client::Api.new("github", token: "bar", token_name: "foo") } + + before(:each) do + # Initialize the API client before running tests + api + end + + after(:each) do + # Clear both cached programs and configuration + HackerOne::Client::Program.instance_variable_set(:@my_programs, nil) + HackerOne::Client.instance_variable_set(:@token, nil) + HackerOne::Client.instance_variable_set(:@token_name, nil) end let(:program) do diff --git a/spec/hackerone/client/report_spec.rb b/spec/hackerone/client/report_spec.rb index 63831e4..44388f1 100644 --- a/spec/hackerone/client/report_spec.rb +++ b/spec/hackerone/client/report_spec.rb @@ -3,11 +3,17 @@ require "spec_helper" RSpec.describe HackerOne::Client::Report do - let(:api) { HackerOne::Client::Api.new("github") } + let(:api) { HackerOne::Client::Api.new("github", token: "bar", token_name: "foo") } - before(:all) do - ENV["HACKERONE_TOKEN_NAME"] = "foo" - ENV["HACKERONE_TOKEN"] = "bar" + before(:each) do + # Initialize the API client before running tests + api + end + + after(:each) do + # Clear both cached programs and configuration + HackerOne::Client.instance_variable_set(:@token, nil) + HackerOne::Client.instance_variable_set(:@token_name, nil) end let(:report) do diff --git a/spec/hackerone/client/reporter_spec.rb b/spec/hackerone/client/reporter_spec.rb index a2f3f54..98e1d3b 100644 --- a/spec/hackerone/client/reporter_spec.rb +++ b/spec/hackerone/client/reporter_spec.rb @@ -3,11 +3,17 @@ require "spec_helper" RSpec.describe HackerOne::Client::Report do - let(:api) { HackerOne::Client::Api.new("github") } + let(:api) { HackerOne::Client::Api.new("github", token: "bar", token_name: "foo") } - before(:all) do - ENV["HACKERONE_TOKEN_NAME"] = "foo" - ENV["HACKERONE_TOKEN"] = "bar" + before(:each) do + # Initialize the API client before running tests + api + end + + after(:each) do + # Clear both cached programs and configuration + HackerOne::Client.instance_variable_set(:@token, nil) + HackerOne::Client.instance_variable_set(:@token_name, nil) end let(:reporters) do diff --git a/spec/hackerone/client/swag_spec.rb b/spec/hackerone/client/swag_spec.rb index 74d1635..65b0b54 100644 --- a/spec/hackerone/client/swag_spec.rb +++ b/spec/hackerone/client/swag_spec.rb @@ -3,11 +3,17 @@ require "spec_helper" RSpec.describe HackerOne::Client::Swag do - let(:api) { HackerOne::Client::Api.new("github") } + let(:api) { HackerOne::Client::Api.new("github", token: "bar", token_name: "foo") } - before(:all) do - ENV["HACKERONE_TOKEN_NAME"] = "foo" - ENV["HACKERONE_TOKEN"] = "bar" + before(:each) do + # Initialize the API client before running tests + api + end + + after(:each) do + # Clear both cached programs and configuration + HackerOne::Client.instance_variable_set(:@token, nil) + HackerOne::Client.instance_variable_set(:@token_name, nil) end let(:program) do @@ -51,7 +57,6 @@ end end - describe "user" do it "returns a user" do user = swag.user diff --git a/spec/hackerone/client/user_spec.rb b/spec/hackerone/client/user_spec.rb index 2a16a75..7524840 100644 --- a/spec/hackerone/client/user_spec.rb +++ b/spec/hackerone/client/user_spec.rb @@ -3,9 +3,17 @@ require "spec_helper" RSpec.describe HackerOne::Client::User do - before(:all) do - ENV["HACKERONE_TOKEN_NAME"] = "foo" - ENV["HACKERONE_TOKEN"] = "bar" + let(:api) { HackerOne::Client::Api.new("github", token: "bar", token_name: "foo") } + + before(:each) do + # Initialize the API client before running tests + api + end + + after(:each) do + # Clear both cached programs and configuration + HackerOne::Client.instance_variable_set(:@token, nil) + HackerOne::Client.instance_variable_set(:@token_name, nil) end describe "find" do diff --git a/spec/hackerone/client_spec.rb b/spec/hackerone/client_spec.rb index b56bdea..bb1d5b6 100644 --- a/spec/hackerone/client_spec.rb +++ b/spec/hackerone/client_spec.rb @@ -4,15 +4,21 @@ require "time" RSpec.describe HackerOne::Client do - let(:api) { HackerOne::Client::Api.new("github") } let(:point_in_time) { DateTime.parse("2017-02-11T16:00:44-10:00") } - - before(:all) do - ENV["HACKERONE_TOKEN_NAME"] = "foo" - ENV["HACKERONE_TOKEN"] = "bar" - end + # Remove this let definition as it conflicts with the one in the report context + # let(:api) { HackerOne::Client::Api.new("github") } context "configuration" do + it "raises error when no credentials are available" do + ENV["HACKERONE_TOKEN"] = nil + ENV["HACKERONE_TOKEN_NAME"] = nil + + client = HackerOne::Client::Api.new("github") + expect { + client.report(200) + }.to raise_error(HackerOne::Client::NotConfiguredError) + end + it "rejects invalid range values for risk classification" do begin expect { HackerOne::Client.low_range = "fred" }.to raise_error(ArgumentError) @@ -23,24 +29,37 @@ end end - it "requires credential env vars" do - begin - ENV["HACKERONE_TOKEN_NAME"] = nil - ENV["HACKERONE_TOKEN"] = nil - expect { - api.report(200) - }.to raise_error(HackerOne::Client::NotConfiguredError) - ensure - ENV["HACKERONE_TOKEN_NAME"] = "foo" - ENV["HACKERONE_TOKEN"] = "bar" - end + it "initializes successfully with explicit credentials" do + client = HackerOne::Client::Api.new("github", token: "mytoken", token_name: "myname") + expect(client.instance_variable_get(:@token)).to eq("mytoken") + expect(client.instance_variable_get(:@token_name)).to eq("myname") end + + it "falls back to ENV vars when no explicit credentials given" do + ENV["HACKERONE_TOKEN"] = "envtoken" + ENV["HACKERONE_TOKEN_NAME"] = "envname" + + client = HackerOne::Client::Api.new("github") + expect(client.instance_variable_get(:@token)).to eq("envtoken") + expect(client.instance_variable_get(:@token_name)).to eq("envname") + ensure + ENV["HACKERONE_TOKEN"] = nil + ENV["HACKERONE_TOKEN_NAME"] = nil + end + end context "#report" do + # This setup should work with the VCR cassette + let(:api) { HackerOne::Client::Api.new("github", token: "bar", token_name: "foo") } + it "fetches and populates a report" do + # Add debug to verify credentials + puts "Debug: token=#{api.instance_variable_get(:@token)}, token_name=#{api.instance_variable_get(:@token_name)}" + VCR.use_cassette(:report) do - expect(api.report(200)).to_not be_nil + report = api.report(200) + expect(report).to_not be_nil end end @@ -58,6 +77,8 @@ end context "#create_report" do + let(:api) { HackerOne::Client::Api.new("github", token: "foo", token_name: "bar") } + it "raises an error if no program is supplied" do expect { HackerOne::Client::Api.new.create_report(title: "hi", summary: "hi", impact: "string", severity_rating: "none", source: "api") @@ -66,7 +87,15 @@ it "creates a new report" do VCR.use_cassette(:create_report) do - expect(api.create_report(title: "hi", summary: "hi", impact: "string", severity_rating: "none", source: "api")).to_not be_nil + report = api.create_report( + title: "hi", + summary: "hi", + impact: "string", + severity_rating: "none", + source: "api" + ) + expect(report).to_not be_nil + expect(report).to be_kind_of(HackerOne::Client::Report) end end @@ -80,6 +109,8 @@ end context "#reports" do + let(:api) { HackerOne::Client::Api.new("github", token: "foo", token_name: "bar") } + it "raises an error if no program is supplied" do expect { HackerOne::Client::Api.new.reports }.to raise_error(ArgumentError) end @@ -97,7 +128,9 @@ it "returns new reports for a given program as default" do VCR.use_cassette(:report_list) do - expect(api.reports(since: point_in_time)).to_not be_empty + reports = api.reports(since: point_in_time) + expect(reports).to_not be_empty + expect(reports.first).to be_kind_of(HackerOne::Client::Report) end end diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb index 5be3eb4..fde1ba9 100644 --- a/spec/spec_helper.rb +++ b/spec/spec_helper.rb @@ -17,4 +17,18 @@ VCR.configure do |config| config.cassette_library_dir = "fixtures/vcr_cassettes" config.hook_into :webmock + + config.register_request_matcher :uri_ignoring_array_indexes do |request1, request2| + uri1 = URI(request1.uri) + uri2 = URI(request2.uri) + + uri1.scheme == uri2.scheme && + uri1.host == uri2.host && + uri1.path == uri2.path && + CGI.parse(uri1.query.to_s).transform_values(&:sort) == CGI.parse(uri2.query.to_s).transform_values(&:sort) + end + + config.default_cassette_options = { + match_requests_on: [:method, :uri_ignoring_array_indexes] + } end