Introduction

Encrypting a single integer is less about the integer itself and more about the security properties you need. Do you need confidentiality, tamper resistance, deterministic output, or a short reversible token. Those requirements lead to different designs. The safe baseline is to serialize the integer to bytes and then use a standard authenticated-encryption scheme rather than inventing a custom numeric transformation.

Start by Defining the Real Requirement

People often say "encrypt this integer" when they actually mean one of these:

• hide the value from users
• prevent tampering with an id in a URL
• produce a reversible token
• avoid exposing sequential identifiers

Those are not identical problems. For example, if you only need to detect tampering, a signed token may be enough. If you need confidentiality, use real encryption.

Safe Baseline: Convert to Bytes and Encrypt

Modern encryption APIs operate on bytes, not on integer types directly. The normal pattern is:

1. convert the integer to bytes
2. encrypt the bytes with authenticated encryption
3. encode the ciphertext for storage or transport

Using Python's cryptography package with Fernet:

1import base64
2from cryptography.fernet import Fernet
3
4key = Fernet.generate_key()
5fernet = Fernet(key)
6
7value = 123456
8plain = str(value).encode("utf-8")
9token = fernet.encrypt(plain)
10
11print(token.decode("utf-8"))
12print(int(fernet.decrypt(token).decode("utf-8")))

This is easy to implement and includes authentication, which means tampering is detected automatically.

If You Need Raw Integer-to-Bytes Conversion

Sometimes you want to preserve the value as a binary integer before encryption rather than converting it to text. Python's to_bytes and from_bytes make that explicit.

1from cryptography.fernet import Fernet
2
3key = Fernet.generate_key()
4fernet = Fernet(key)
5
6value = 123456
7plain = value.to_bytes(8, byteorder="big", signed=False)
8token = fernet.encrypt(plain)
9restored = int.from_bytes(fernet.decrypt(token), byteorder="big", signed=False)
10
11print(restored)

This is useful when you need fixed-width numeric encoding.

Why Not Use a Homemade Formula

A common bad idea is something like:

• multiply by a secret constant
• XOR with a secret number
• shift digits around
• apply modular arithmetic manually

Those methods may obscure the number, but they are not a replacement for well-studied encryption. They usually fail under even light inspection, and many are reversible from a handful of examples.

If this value matters enough to protect, use a standard library and a standard primitive.

Signed Tokens Versus Encrypted Tokens

If your goal is to stop users from editing an integer id in a URL, encryption may not actually be required. A signed token can be enough.

That design says:

• the client may see the value
• the client must not be able to forge a different valid value

If secrecy matters, use encryption. If integrity is the only goal, signing can be simpler and more transparent.

Output Length and Determinism Matter

One reason people ask this question is that they want a short encrypted integer that stays compact. Standard authenticated encryption does not preserve short numeric length. Ciphertext is longer than the original value because it includes randomness and authentication data.

That is expected and desirable.

If you require:

• fixed-length output
• decimal-only output
• deterministic encryption

then you are no longer asking for a simple generic answer. You are in a specialized design space that needs careful cryptographic review.

Use Cases That Should Push You Toward Tokenization Instead

If you only need opaque external identifiers, sometimes the best answer is not encryption at all. A random token or server-side lookup table may be simpler and safer than reversible client-side ciphertext.

In other words, do not use encryption automatically when the real requirement is just "do not expose internal ids directly."

Common Pitfalls

• Using homemade integer scrambling instead of real encryption.
• Failing to distinguish confidentiality from tamper detection.
• Expecting ciphertext to stay as short and neat as the original integer.
• Forgetting that standard crypto APIs work on bytes, not integer types directly.
• Choosing encryption when tokenization or signing would better match the requirement.

Summary

• A single integer should be serialized to bytes and encrypted with a standard authenticated-encryption library.
• 'Fernet is a good simple baseline in Python for reversible protected tokens.'
• If you only need tamper detection, signed tokens may be enough.
• Do not invent your own numeric encryption scheme.
• The right answer depends on whether you need secrecy, integrity, compact output, or opaque identifiers.