JWT Generating Full Guide: Issue, HS256 Signature, Keys and Interlock

1. Issuance perspective: what are the three paragraphs each writing?

Tight sequences remain:

base64url(header).base64url(payload).base64url(signature)

Unlike "code only", you must decide on each paragraph at your own initiative.

Header: The algorithm contract, not the decoration.

Header:

{
  "alg": "HS256",
  "typ": "JWT"
}

Don't do it."To be convenient" on the client alg Replace with none or allow the caller to specify an algorithm. The algorithms often confuse the root cause of the attack: the signing firm trusted Token's self-reported. alg, the wrong type of key was used.

Payload: Only "public + expired" statements

{
  "sub": "u_1024",
  "iss": "https://auth.example.com",
  "aud": "api.example.com",
  "iat": 1723180800,
  "exp": 1723184400,
  "scope": "read:orders",
  "role": "ops"
}

List of issues (in order of priority):

1. exp: Almost all of Token production should be available; The U.S. calls are much safer (5-15 minutes) than "one year without expiry".
2. iat / nbfThe following video shows the number of people who have been killed by the police:nbf The current time is more than "not yet in effect".
3. sub: stable master marking; No SLB is explicitly used as a sole basis unless the product expressly requires and is acceptable for disclosure.
4. iss / audMulti-service, multi-client, write-in to avoid Token being used in a different API.
5. Operations：scope、tenant_id、role etc.; Type is stable (string vs numbers, single values vs array).

Ban on writing: Password, refreshing tokens, complete bank cards, permanent API Secret, direct access points. Payload can be decoded by any holder, Base64URL - this is a format design, not an omission.

Signature: "Keyprints" for the first two paragraphs

For HS256, the normative meaning is:

HMAC-SHA256(
  base64url(header) + "." + base64url(payload),
  secret
)

Then we'll do the binary result Base64URL, get the third paragraph. The three most easily wrong things to do when they are generated:

• Signing input missing the middle Node.or sign the whole JWT again;
• Standard Base64 for Header/Payload + / and =(i) The following:
• The key is changed, the UTF-8/UTF-16 is mixed, or the "example key" and "real key for environmental variables" are mixed.

2. Pre-generation type: HS256 or asymmetric

The generation of landable sites is practiced to HS256 Main: HMAC generator is responsible for "Key Summary" and JWT decoding is responsible for "Strike + Optional HS256 Signing". RS256 Private key calculations do not work the whole process - production is a mature library - in the safety model of the browser tool.

Key length experience (symmetry):

• HS256: Key entropy not lower than 256 bit (32 bytes random) secret、123456, the project name is the key;
• Rotation: new key online kid (b) Distinction; Old Token is in exp The old key may still be used to verify the internal contents and the natural phase-out after expiry;
• Storage: Environmental variable / key hosting, not in Git, not in front-end package, not in guide screenshot.

3. Base64URL and "signatureable string"

Half of the generation failures are in code, not code.

Available Base64 tools Understand coding differences, but Dismantling and HS256 for whole JWT I should still be back. JWT decoder。 Payload, when it's big, use it first. JSON Format proofread fields, encoded token.

Minimum handshake example (structure only, key is for presentation):

header  = {"alg":"HS256","typ":"JWT"}
payload = {"sub":"demo","exp":1893456000}
signing_input = base64url(header) + "." + base64url(payload)
signature     = base64url( HMAC_SHA256(signing_input, "demo-only-secret") )
jwt           = signing_input + "." + signature

I'll get it. jwt Paste decoding device: should be visible sub/exp； Fill with the same in the check box demo-only-secret and when the algorithm HS256 is, the signature should be shown to be valid. One byte is changed and the approval should fail — this is the definition of “success generation”, not “the string looks like three segments”.

4. Walking through KiloCell of cells to "generate materials and self-censorship"

The warehouse currently does not have a single "one-key form out of JWT" page. Generate Practice By HMAC Generator + JWT Decodingr (and Base64/ JSON) Composition. It's more efficient than half-posting Token in the chat.

Preparation of statements (recommendations first JSON tool)

1. Open JSON FormatWrite Header and Payload separately, confirm legal JSON.
2. - Put it on. exp Written sec Level Unix time; You can observe both states as "unexpired / expired" with short expiry.
3. The business field only retains the minimum set required for the connection, avoiding the need to plug dozens of claires at a time.

Getting signed input

1. Header and Payload are separate Base64URLs (no fill).
2. In English, in a single dot. signing_input。
3. The string of this step must be the first two paragraphs of the final JWT Same by characterOtherwise, HMAC will be wrong.

C. Signing material using HMAC generator

1. Open HMAC Generators。
2. Algorithms and Header alg corresponds to HMAC-SHA256 (or the SHA variant that you agreed in your document).
3. Key Fill in shared keys;Data Complete signing_input(Two paragraphs + midpoint), not just Payload.
4. Confirm output code after generation: JWT 3 needs Base64URL Form. If the tool is defaulting on hex/ Normal Base64, convert the library document you use or complete the final assembly in the service repository that supports JWT.
5. Assembly:jwt = signing_input + "." + signature_base64url。

D. Close the ring with the decodor immediately

1. Open JWT decoder。
2. Just paste Token Body, don't bring Bearer 。
3. Checking Header's algPayload's. exp Local time and business field.
4. Fill in "Pertify Signature" Same Key(HS256 path only): this round is established by passing; Failure returns to B/C check encoded and key instead of changing business interfaces first.
5. The two Payloads are to be copied to the JSON tool for a structured comparison when comparing the two issuance differences.

Tool boundary (avoid expected misalignment)

• HMAC Generators： General message authentication codes; Helps you understand and calculate the "key + message summary" or other non-JWT scenes like Webbook signature.
• JWT decoding device: Three paragraphs.exp/iat Readable, Optional HS256 (b) Signing; Not responsible for RSA private key issue.
• Hash Generators： (a) A key summary for the document/text fingerprint;couldn'tOther Organiser Hash Guide）。
• Officially issued: An eco-ecological JWT library such as Node / Java / Go (processing encoding, time, key and anti-mixing configuration); Browser small tools are used for teaching, connecting and typifying, not IdP.

5. Common rollovers and comparisons after issuance

6. Real work scene

Scenario A: Backend not ready. Frontend to pre-empt the false login with access.

Make a short expired one.role/scope Full HS256 Token, written in local development gateway or mock. Use the decoding to confirm the field and then let the front end be true. Authorization Head.Keys are only left locally .env, the advance of shared front-end warehouses is prohibited. Fake Token iss Recommendation dev- Prefixes, avoid prefixing.

Scret: Two environments are different, and the connection "same user" is just one side away.

Don't start with business code. Sign one each of the same Payload, decoded against whether Header is HS256, then sign with their respective environment keys on the decoder. If A key can verify A votes, cannot check B tickets, the problem is distributed in the key and not on the user chart.

C: Migration Session → JWT, with the "minimal collection"

The following is a list of the most important topics that are being discussed:sub、exp、iat、sid(session version)auth_time。 Each example is issued by table, using an decoder as a receiving and inspection tool: the creation of scripts for missing fields has failed. It is more time-consuming than the 403 log inverted field.

Scene D: Suspected of forgery Token

Take a line-on-line (or audit) Token, decode it. alg and kid。 If alg Yes none or not in accordance with the document, as per the incident. HS256 Signing with current key: Failure indicates that the system is not issued; And we'll check it out. exp With permission to claim is not used for business. The side protections to be generated are:Private keys/keys are not issued, and the caller decides against the alg.

7. Security and key: Write in process when generated

• Key for password: Sufficient length and randomness; Rotation kid； Disclosure is the rotation and, where appropriate, cancellation of the unexpired ticket.
• Short Expiry + Refresh token: Visit Token minutes — hour; Refresh Token Storage Service to cancel storage, not just for excessive length exp。
• Generate environmental isolation: Develop/ pre-issue/ manufacture key separation; Prohibits the production of keys to appear in presentations.
• Transfer: Only HTTPS; Do not use the complete Token as URL long-term query parameter (logs and reper will leak).
• Log: Just call. jti Or several before and after Token; Full JWT log entry is the same as a leak.
• Library Configuration: A list of algorithms that are allowed to write a death by the approving port; Close none； HS and RS do not mix the "Mixable Signing" function.
• Browser tool: Thousands of local processing machines are still not posted on shared screens or recorded presentations for high-capacity production tickets.

8. How to select the tools

PUT:Declares that signing signature input encoder sealing sealing → business library is issued as production issue by JSON proofing encodering tagging input → HMAC.

The first one is "reading the tickets" and "reading them." JWT Decoding Full Guide； Focus How do you sign the tickets?。

FAQ

Continue reading

The "HMAC decoded signature" is done locally with a demonstration key. Confirms that the same contract of claim is entered into the service-end issuance code after you have made contact. When you are wrong, you have to set the key to signing input instead of changing the business and gateway at the same time.