Q.To secure your account, whether it be an email, online bank account or any other account, it is important that we use authentication. Use your programming expertise to create a program using user defined function named login that accepts userid and password as parameters (login(uid,pwd)) that displays a message “account blocked” in case of three wrong attempts. The login is successful if the user enters user ID as "ADMIN" and password as "St0rE@1". On successful login, display a message “login successful”.

Authentication Logic — The Gatekeeper's Question

Imagine you're at the door of a secure building. A guard stops you and asks: "Who are you, and how do I know you're telling the truth?" That's authentication in real life. In computing, authentication logic is the set of rules that answers exactly those two questions.

The first question is about identity — you claim to be someone (a username, an email, an ID number). The second question is about proof — you must provide evidence that you really are that person. The logic is the decision procedure: given the claim and the evidence, should the system let you in or not?

The Core Idea: Matching a Claim Against a Secret

At its simplest, authentication logic works like this:

1. The user presents an identifier (e.g., "I am user123").
2. The user presents a credential (e.g., a password, a fingerprint, a security token).
3. The system looks up the stored secret associated with that identifier.
4. The system compares the presented credential against the stored secret.
5. If they match, access is granted. If not, access is denied.

That's the skeleton. But real authentication logic is more nuanced — because the "matching" step can be done in many ways, and the "stored secret" must never be stored in plain text.

The Precise Statement

Let's formalise it. Let:

• $U$ be the set of all user identifiers.
• $C$ be the set of all possible credentials (passwords, biometric data, tokens).
• $S$ be the set of stored secrets (hashed passwords, etc.).

An authentication system consists of:

1. A registration function $R: U \times C \to S$ that, during sign-up, takes an identifier and a credential and produces a stored secret. Typically $R(u, c) = H(c)$ where $H$ is a cryptographic hash function.

2. A verification function $V: U \times C \times S \to \{\text{accept}, \text{reject}\}$ that, during login, takes an identifier, a presented credential, and the stored secret, and decides whether to grant access. Typically $V(u, c, s) = \text{accept}$ if and only if $H(c) = s$.

The authentication logic is the algorithm implementing $V$. It must satisfy:

• Correctness: If the correct credential is presented, $V$ always accepts.
• Security: If an incorrect credential is presented, $V$ should reject with overwhelming probability (no false positives).
• One-way property: Given $s$, it should be computationally infeasible to find any $c$ such that $H(c) = s$.

Beyond Passwords: Multi-Factor Logic

Authentication logic isn't limited to "something you know" (passwords). It extends to three categories:

Multi-factor authentication (MFA) combines two or more factors. The logic becomes:

Each factor's verification logic is independent, but the overall decision is a logical AND.

A Concrete Example

Suppose a user registers with username alice and password MyP@ss123. The system:

1. Hashes the password: $H(\text{MyP@ss123}) = \text{a1b2c3d4...}$ (a fixed-length string).
2. Stores (alice, a1b2c3d4...) in the database.

Later, Alice logs in with username alice and password MyP@ss123. The system:

1. Looks up the stored hash for alice: a1b2c3d4....
2. Hashes the presented password: $H(\text{MyP@ss123}) = \text{a1b2c3d4...}$.
3. Compares: they match → accept.

If an attacker tries MyP@ss124, the hash will be completely different (avalanche effect), and the comparison fails → reject.

Why "Logic" Matters

The word "logic" is deliberate. Authentication is a decision procedure — a set of rules that always produces a binary outcome. It's not probabilistic (except biometrics), not subjective, not negotiable. The logic must be:

• Deterministic: Same inputs always give same output.
• Complete: Every possible input pair produces a decision.
• Sound: No false acceptances for valid credentials.

In exam contexts, you'll often be asked to trace through this logic step by step — given a hash function and a database, determine whether a login attempt succeeds. The key is to remember: you never compare passwords directly; you compare hashes.

The Big Picture

Authentication logic is the gatekeeper of every digital system you use. It's the reason your bank doesn't know your actual password but can still verify it. It's the reason a stolen database of hashes doesn't immediately give attackers access to your accounts (though they can try to crack the hashes offline — that's a different problem).

Master this concept, and you understand the foundation of all computer security. Everything else — encryption, access control, digital signatures — builds on this simple idea: prove who you are, or stay out.