# Sécurité - Premiers pas { #security-first-steps }

Imaginons que vous ayez votre API de **backend** sur un certain domaine.

Et vous avez un **frontend** sur un autre domaine ou dans un chemin différent du même domaine (ou dans une application mobile).

Et vous voulez que le **frontend** puisse s'authentifier auprès du **backend**, en utilisant un **username** et un **password**.

Nous pouvons utiliser **OAuth2** pour construire cela avec **FastAPI**.

        // Then
        assertFalse(Arrays.equals(decKey300, decKey311), "Decryption keys should be different for different dialects");
    }

    @Test
    @DisplayName("Should derive different keys for different purposes with same dialect")
    void testDeriveKeys_DifferentPurposes() {
        // Given
        int dialect = Smb2Constants.SMB2_DIALECT_0311;

				// but if we do see a difference with local domain IPs with
				// hostSlice from etcd then we should update with newer
				// domainIPs, we proceed to do that here.
				bucketsToBeUpdated.Add(bucket)
				continue
			}

			// No IPs seem to intersect, this means that bucket exists but has
			// different IP addresses perhaps from a different deployment.

        // Results should be different
        boolean different = false;
        for (int i = 0; i < result1.length; i++) {
            if (result1[i] != result2[i]) {
                different = true;
                break;
            }
        }
        assertEquals(true, different, "Different keys should produce different HMAC values");
    }

    @Test

        CharMappingItem item4 = new CharMappingItem(4L, inputs1, "different");

        // Same inputs and output should have same hash code
        assertEquals(item1.hashCode(), item2.hashCode());

        // Different inputs should have different hash code
        assertNotSame(item1.hashCode(), item3.hashCode());

        // Same inputs but different output should have different hash code

        byte[] encrypted2 = storage.encryptCredentials(plaintext.clone());

        // Should produce different ciphertexts due to random IV
        assertFalse(Arrays.equals(encrypted1, encrypted2), "Different encryptions should produce different ciphertexts");

        // But both should decrypt to same plaintext
        char[] decrypted1 = storage.decryptCredentials(encrypted1);

        ProtwordsItem item2 = new ProtwordsItem(2, "word");
        ProtwordsItem item3 = new ProtwordsItem(1, "different");

        // Same input should have same hashCode regardless of id
        assertEquals(item1.hashCode(), item2.hashCode());

        // Different input should have different hashCode
        assertNotSame(item1.hashCode(), item3.hashCode());

        // Consistent hashCode

### Concurrency and Burgers { #concurrency-and-burgers }

This idea of **asynchronous** code described above is also sometimes called **"concurrency"**. It is different from **"parallelism"**.

**Concurrency** and **parallelism** both relate to "different things happening more or less at the same time".

        Instant monotonic = MonotonicClock.now();
        Instant system = Instant.now();

        // The difference should be relatively small (allow for 1 second max)
        Duration difference = Duration.between(monotonic, system).abs();
        assertTrue(difference.getSeconds() <= 1, "Monotonic time should be reasonably aligned with system time");
    }

        assertEquals(32, derived3.length, "Derived key should have correct length");

        assertFalse(Arrays.equals(derived1, derived2), "Different labels should produce different keys");
        assertFalse(Arrays.equals(derived1, derived3), "Different contexts should produce different keys");
    }

    @Test
    public void testStoreNullKey() {