Security and Cost in System Design

package main

import (
	"fmt"
	"strings"
)

// commas writes 1234567 as 1,234,567.
func commas(n int64) string {
	s := fmt.Sprint(n)
	var b strings.Builder
	for i, c := range s {
		if i > 0 && (len(s)-i)%3 == 0 {
			b.WriteByte(',')
		}
		b.WriteRune(c)
	}
	return b.String()
}

// 1. Authorisation. Logged in is not the same as allowed: rahim asks for karim's order.
func authz() {
	owner := map[int]string{101: "rahim", 102: "karim"}
	get := func(user string, order int, checkOwner bool) string {
		if user == "" {
			return "401 log in first"
		}
		if checkOwner && owner[order] != user {
			return "404 not found" // don't even confirm the order exists
		}
		return fmt.Sprintf("200 order %d (owner %s)", order, owner[order])
	}
	fmt.Println("rahim is logged in and requests GET /orders/102 (karim's):")
	fmt.Printf("  only checks login:     %s\n", get("rahim", 102, false))
	fmt.Printf("  checks the owner too:  %s\n", get("rahim", 102, true))
}

// 2. Abuse: guessing a 4-digit OTP (10,000 codes) at 100 tries a second. The real code is
// 7351; the attacker simply tries 0000, 0001, 0002, ...
func guess(limit int) (tries int, found bool) {
	const secret = 7351
	for code := 0; code < 10_000; code++ {
		if limit > 0 && tries == limit {
			return tries, false // the code is burned: a new one must be requested
		}
		tries++
		if code == secret {
			return tries, true
		}
	}
	return tries, false
}

func otp() {
	fmt.Println("4-digit OTP, attacker tries 100 codes a second:")
	tries, found := guess(0)
	fmt.Printf("  no limit:                    found=%t after %d tries (%d s)\n", found, tries, tries/100)
	tries, found = guess(5)
	fmt.Printf("  5 tries, then the code dies: found=%t after %d tries; odds per code sent: 1 in %d\n", found, tries, 10_000/5)
}

// 3. Cost of the photo app from the estimation chapter, one month. Prices are assumed round
// numbers, in US cents, to compare options; check your provider's real prices.
func cost() {
	const (
		servers       = 5 * 70_00  // 5 app servers at $70
		database      = 2 * 400_00 // primary + standby at $400
		storage       = 73 * 20_00 // 73 TB stored after year one, $20 per TB
		egressGB      = 1_500_000  // 100M views a day x 500 KB x 30 days = 1,500 TB
		directPerGB   = 5          // cents per GB straight from the cloud
		cdnPerGB      = 1          // cents per GB from a CDN
		originShareOf = 5          // % of CDN traffic that still comes from the origin
	)
	direct := int64(egressGB * directPerGB)
	viaCDN := int64(egressGB*cdnPerGB + egressGB*originShareOf/100*directPerGB)
	base := int64(servers + database + storage)
	fmt.Println("one month of the photo app (assumed prices):")
	fmt.Printf("  servers $%s, database $%s, storage $%s\n", commas(servers/100), commas(database/100), commas(storage/100))
	fmt.Printf("  serving photos from the cloud directly: $%s egress, $%s in total (egress %d%%)\n",
		commas(direct/100), commas((base+direct)/100), direct*100/(base+direct))
	fmt.Printf("  serving photos through a CDN:           $%s egress, $%s in total\n", commas(viaCDN/100), commas((base+viaCDN)/100))
}

func main() {
	authz()
	otp()
	cost()
}

def commas(n: int) -> str:
    return f"{n:,}"


def authz() -> None:
    """1. Authorisation. Logged in is not the same as allowed: rahim asks for karim's order."""
    owner = {101: "rahim", 102: "karim"}

    def get(user: str, order: int, check_owner: bool) -> str:
        if not user:
            return "401 log in first"
        if check_owner and owner.get(order) != user:
            return "404 not found"  # don't even confirm the order exists
        return f"200 order {order} (owner {owner[order]})"

    print("rahim is logged in and requests GET /orders/102 (karim's):")
    print(f"  only checks login:     {get('rahim', 102, False)}")
    print(f"  checks the owner too:  {get('rahim', 102, True)}")


def guess(limit: int) -> tuple[int, bool]:
    """2. Abuse: guessing a 4-digit OTP (10,000 codes) at 100 tries a second. The real code is
    7351; the attacker simply tries 0000, 0001, 0002, ..."""
    secret, tries = 7351, 0
    for code in range(10_000):
        if limit > 0 and tries == limit:
            return tries, False  # the code is burned: a new one must be requested
        tries += 1
        if code == secret:
            return tries, True
    return tries, False


def otp() -> None:
    print("4-digit OTP, attacker tries 100 codes a second:")
    tries, found = guess(0)
    print(f"  no limit:                    found={str(found).lower()} after {tries} tries ({tries // 100} s)")
    tries, found = guess(5)
    print(f"  5 tries, then the code dies: found={str(found).lower()} after {tries} tries; odds per code sent: 1 in {10_000 // 5}")


def cost() -> None:
    """3. Cost of the photo app from the estimation chapter, one month. Prices are assumed round
    numbers, in US cents, to compare options; check your provider's real prices."""
    servers = 5 * 70_00  # 5 app servers at $70
    database = 2 * 400_00  # primary + standby at $400
    storage = 73 * 20_00  # 73 TB stored after year one, $20 per TB
    egress_gb = 1_500_000  # 100M views a day x 500 KB x 30 days = 1,500 TB
    direct_per_gb = 5  # cents per GB straight from the cloud
    cdn_per_gb = 1  # cents per GB from a CDN
    origin_share = 5  # % of CDN traffic that still comes from the origin

    direct = egress_gb * direct_per_gb
    via_cdn = egress_gb * cdn_per_gb + egress_gb * origin_share // 100 * direct_per_gb
    base = servers + database + storage
    print("one month of the photo app (assumed prices):")
    print(f"  servers ${commas(servers // 100)}, database ${commas(database // 100)}, storage ${commas(storage // 100)}")
    print(f"  serving photos from the cloud directly: ${commas(direct // 100)} egress, "
          f"${commas((base + direct) // 100)} in total (egress {direct * 100 // (base + direct)}%)")
    print(f"  serving photos through a CDN:           ${commas(via_cdn // 100)} egress, ${commas((base + via_cdn) // 100)} in total")


authz()
otp()
cost()

const div = (a: number, b: number) => Math.floor(a / b);
/** 1234567 as 1,234,567, without depending on the machine's locale. */
const commas = (n: number) => String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ",");

/** 1. Authorisation. Logged in is not the same as allowed: rahim asks for karim's order. */
function authz() {
  const owner = new Map([[101, "rahim"], [102, "karim"]]);
  const get = (user: string, order: number, checkOwner: boolean): string => {
    if (user === "") return "401 log in first";
    if (checkOwner && owner.get(order) !== user) return "404 not found"; // don't even confirm the order exists
    return `200 order ${order} (owner ${owner.get(order)})`;
  };
  console.log("rahim is logged in and requests GET /orders/102 (karim's):");
  console.log(`  only checks login:     ${get("rahim", 102, false)}`);
  console.log(`  checks the owner too:  ${get("rahim", 102, true)}`);
}

/** 2. Abuse: guessing a 4-digit OTP (10,000 codes) at 100 tries a second. The real code is
 * 7351; the attacker simply tries 0000, 0001, 0002, ... */
function guess(limit: number): [number, boolean] {
  const secret = 7351;
  let tries = 0;
  for (let code = 0; code < 10_000; code++) {
    if (limit > 0 && tries === limit) return [tries, false]; // the code is burned: a new one must be requested
    tries++;
    if (code === secret) return [tries, true];
  }
  return [tries, false];
}

function otp() {
  console.log("4-digit OTP, attacker tries 100 codes a second:");
  let [tries, found] = guess(0);
  console.log(`  no limit:                    found=${found} after ${tries} tries (${div(tries, 100)} s)`);
  [tries, found] = guess(5);
  console.log(`  5 tries, then the code dies: found=${found} after ${tries} tries; odds per code sent: 1 in ${div(10_000, 5)}`);
}

/** 3. Cost of the photo app from the estimation chapter, one month. Prices are assumed round
 * numbers, in US cents, to compare options; check your provider's real prices. */
function cost() {
  const servers = 5 * 70_00; // 5 app servers at $70
  const database = 2 * 400_00; // primary + standby at $400
  const storage = 73 * 20_00; // 73 TB stored after year one, $20 per TB
  const egressGB = 1_500_000; // 100M views a day x 500 KB x 30 days = 1,500 TB
  const directPerGB = 5; // cents per GB straight from the cloud
  const cdnPerGB = 1; // cents per GB from a CDN
  const originShare = 5; // % of CDN traffic that still comes from the origin

  const direct = egressGB * directPerGB;
  const viaCDN = egressGB * cdnPerGB + div(egressGB * originShare, 100) * directPerGB;
  const base = servers + database + storage;
  console.log("one month of the photo app (assumed prices):");
  console.log(`  servers $${commas(div(servers, 100))}, database $${commas(div(database, 100))}, storage $${commas(div(storage, 100))}`);
  console.log(
    `  serving photos from the cloud directly: $${commas(div(direct, 100))} egress, $${commas(div(base + direct, 100))} in total (egress ${div(direct * 100, base + direct)}%)`,
  );
  console.log(`  serving photos through a CDN:           $${commas(div(viaCDN, 100))} egress, $${commas(div(base + viaCDN, 100))} in total`);
}

authz();
otp();
cost();

use std::collections::HashMap;

/// 1234567 as 1,234,567.
fn commas(n: i64) -> String {
    let s = n.to_string();
    let mut out = String::new();
    for (i, c) in s.chars().enumerate() {
        if i > 0 && (s.len() - i) % 3 == 0 {
            out.push(',');
        }
        out.push(c);
    }
    out
}

/// 1. Authorisation. Logged in is not the same as allowed: rahim asks for karim's order.
fn authz() {
    let owner = HashMap::from([(101, "rahim"), (102, "karim")]);
    let get = |user: &str, order: i32, check_owner: bool| -> String {
        if user.is_empty() {
            return "401 log in first".to_string();
        }
        if check_owner && owner.get(&order) != Some(&user) {
            return "404 not found".to_string(); // don't even confirm the order exists
        }
        format!("200 order {order} (owner {})", owner[&order])
    };
    println!("rahim is logged in and requests GET /orders/102 (karim's):");
    println!("  only checks login:     {}", get("rahim", 102, false));
    println!("  checks the owner too:  {}", get("rahim", 102, true));
}

/// 2. Abuse: guessing a 4-digit OTP (10,000 codes) at 100 tries a second. The real code is
/// 7351; the attacker simply tries 0000, 0001, 0002, ...
fn guess(limit: i32) -> (i32, bool) {
    let secret = 7351;
    let mut tries = 0;
    for code in 0..10_000 {
        if limit > 0 && tries == limit {
            return (tries, false); // the code is burned: a new one must be requested
        }
        tries += 1;
        if code == secret {
            return (tries, true);
        }
    }
    (tries, false)
}

fn otp() {
    println!("4-digit OTP, attacker tries 100 codes a second:");
    let (tries, found) = guess(0);
    println!("  no limit:                    found={found} after {tries} tries ({} s)", tries / 100);
    let (tries, found) = guess(5);
    println!("  5 tries, then the code dies: found={found} after {tries} tries; odds per code sent: 1 in {}", 10_000 / 5);
}

/// 3. Cost of the photo app from the estimation chapter, one month. Prices are assumed round
/// numbers, in US cents, to compare options; check your provider's real prices.
fn cost() {
    let servers: i64 = 5 * 70_00; // 5 app servers at $70
    let database: i64 = 2 * 400_00; // primary + standby at $400
    let storage: i64 = 73 * 20_00; // 73 TB stored after year one, $20 per TB
    let egress_gb: i64 = 1_500_000; // 100M views a day x 500 KB x 30 days = 1,500 TB
    let direct_per_gb = 5; // cents per GB straight from the cloud
    let cdn_per_gb = 1; // cents per GB from a CDN
    let origin_share = 5; // % of CDN traffic that still comes from the origin

    let direct = egress_gb * direct_per_gb;
    let via_cdn = egress_gb * cdn_per_gb + egress_gb * origin_share / 100 * direct_per_gb;
    let base = servers + database + storage;
    println!("one month of the photo app (assumed prices):");
    println!("  servers ${}, database ${}, storage ${}", commas(servers / 100), commas(database / 100), commas(storage / 100));
    println!(
        "  serving photos from the cloud directly: ${} egress, ${} in total (egress {}%)",
        commas(direct / 100),
        commas((base + direct) / 100),
        direct * 100 / (base + direct)
    );
    println!("  serving photos through a CDN:           ${} egress, ${} in total", commas(via_cdn / 100), commas((base + via_cdn) / 100));
}

fn main() {
    authz();
    otp();
    cost();
}

import java.util.Map;

public class Main {
    /** 1234567 as 1,234,567, without depending on the machine's locale. */
    static String commas(long n) {
        String s = Long.toString(n);
        StringBuilder b = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            if (i > 0 && (s.length() - i) % 3 == 0) b.append(',');
            b.append(s.charAt(i));
        }
        return b.toString();
    }

    static final Map<Integer, String> OWNER = Map.of(101, "rahim", 102, "karim");

    /** 1. Authorisation. Logged in is not the same as allowed: rahim asks for karim's order. */
    static String get(String user, int order, boolean checkOwner) {
        if (user.isEmpty()) return "401 log in first";
        if (checkOwner && !user.equals(OWNER.get(order))) return "404 not found"; // don't even confirm the order exists
        return "200 order " + order + " (owner " + OWNER.get(order) + ")";
    }

    static void authz() {
        System.out.println("rahim is logged in and requests GET /orders/102 (karim's):");
        System.out.println("  only checks login:     " + get("rahim", 102, false));
        System.out.println("  checks the owner too:  " + get("rahim", 102, true));
    }

    record Guess(int tries, boolean found) {}

    /** 2. Abuse: guessing a 4-digit OTP (10,000 codes) at 100 tries a second. The real code is
     *  7351; the attacker simply tries 0000, 0001, 0002, ... */
    static Guess guess(int limit) {
        final int secret = 7351;
        int tries = 0;
        for (int code = 0; code < 10_000; code++) {
            if (limit > 0 && tries == limit) return new Guess(tries, false); // the code is burned: a new one must be requested
            tries++;
            if (code == secret) return new Guess(tries, true);
        }
        return new Guess(tries, false);
    }

    static void otp() {
        System.out.println("4-digit OTP, attacker tries 100 codes a second:");
        Guess g = guess(0);
        System.out.printf("  no limit:                    found=%b after %d tries (%d s)%n", g.found(), g.tries(), g.tries() / 100);
        g = guess(5);
        System.out.printf("  5 tries, then the code dies: found=%b after %d tries; odds per code sent: 1 in %d%n", g.found(), g.tries(), 10_000 / 5);
    }

    /** 3. Cost of the photo app from the estimation chapter, one month. Prices are assumed round
     *  numbers, in US cents, to compare options; check your provider's real prices. */
    static void cost() {
        final long servers = 5 * 70_00;      // 5 app servers at $70
        final long database = 2 * 400_00;    // primary + standby at $400
        final long storage = 73 * 20_00;     // 73 TB stored after year one, $20 per TB
        final long egressGB = 1_500_000;     // 100M views a day x 500 KB x 30 days = 1,500 TB
        final long directPerGB = 5;          // cents per GB straight from the cloud
        final long cdnPerGB = 1;             // cents per GB from a CDN
        final long originShare = 5;          // % of CDN traffic that still comes from the origin

        long direct = egressGB * directPerGB;
        long viaCDN = egressGB * cdnPerGB + egressGB * originShare / 100 * directPerGB;
        long base = servers + database + storage;
        System.out.println("one month of the photo app (assumed prices):");
        System.out.printf("  servers $%s, database $%s, storage $%s%n", commas(servers / 100), commas(database / 100), commas(storage / 100));
        System.out.printf("  serving photos from the cloud directly: $%s egress, $%s in total (egress %d%%)%n",
                commas(direct / 100), commas((base + direct) / 100), direct * 100 / (base + direct));
        System.out.printf("  serving photos through a CDN:           $%s egress, $%s in total%n", commas(viaCDN / 100), commas((base + viaCDN) / 100));
    }

    public static void main(String[] args) {
        authz();
        otp();
        cost();
    }
}

#include <cstdint>
#include <cstdio>
#include <map>
#include <string>
#include <utility>

// 1234567 as 1,234,567.
std::string commas(long long n) {
    std::string s = std::to_string(n), out;
    for (size_t i = 0; i < s.size(); i++) {
        if (i > 0 && (s.size() - i) % 3 == 0) out += ',';
        out += s[i];
    }
    return out;
}

// 1. Authorisation. Logged in is not the same as allowed: rahim asks for karim's order.
void authz() {
    const std::map<int, std::string> owner = {{101, "rahim"}, {102, "karim"}};
    auto get = [&](const std::string& user, int order, bool checkOwner) -> std::string {
        if (user.empty()) return "401 log in first";
        if (checkOwner && owner.at(order) != user) return "404 not found";  // don't even confirm the order exists
        return "200 order " + std::to_string(order) + " (owner " + owner.at(order) + ")";
    };
    std::printf("rahim is logged in and requests GET /orders/102 (karim's):\n");
    std::printf("  only checks login:     %s\n", get("rahim", 102, false).c_str());
    std::printf("  checks the owner too:  %s\n", get("rahim", 102, true).c_str());
}

// 2. Abuse: guessing a 4-digit OTP (10,000 codes) at 100 tries a second. The real code is
// 7351; the attacker simply tries 0000, 0001, 0002, ...
std::pair<int, bool> guess(int limit) {
    const int secret = 7351;
    int tries = 0;
    for (int code = 0; code < 10'000; code++) {
        if (limit > 0 && tries == limit) return {tries, false};  // the code is burned: a new one must be requested
        tries++;
        if (code == secret) return {tries, true};
    }
    return {tries, false};
}

void otp() {
    std::printf("4-digit OTP, attacker tries 100 codes a second:\n");
    auto [tries, found] = guess(0);
    std::printf("  no limit:                    found=%s after %d tries (%d s)\n", found ? "true" : "false", tries, tries / 100);
    auto [tries5, found5] = guess(5);
    std::printf("  5 tries, then the code dies: found=%s after %d tries; odds per code sent: 1 in %d\n", found5 ? "true" : "false",
                tries5, 10'000 / 5);
}

// 3. Cost of the photo app from the estimation chapter, one month. Prices are assumed round
// numbers, in US cents, to compare options; check your provider's real prices.
void cost() {
    const long long servers = 5 * 70'00;    // 5 app servers at $70
    const long long database = 2 * 400'00;  // primary + standby at $400
    const long long storage = 73 * 20'00;   // 73 TB stored after year one, $20 per TB
    const long long egressGB = 1'500'000;   // 100M views a day x 500 KB x 30 days = 1,500 TB
    const long long directPerGB = 5;        // cents per GB straight from the cloud
    const long long cdnPerGB = 1;           // cents per GB from a CDN
    const long long originShare = 5;        // % of CDN traffic that still comes from the origin

    long long direct = egressGB * directPerGB;
    long long viaCDN = egressGB * cdnPerGB + egressGB * originShare / 100 * directPerGB;
    long long base = servers + database + storage;
    std::printf("one month of the photo app (assumed prices):\n");
    std::printf("  servers $%s, database $%s, storage $%s\n", commas(servers / 100).c_str(), commas(database / 100).c_str(),
                commas(storage / 100).c_str());
    std::printf("  serving photos from the cloud directly: $%s egress, $%s in total (egress %lld%%)\n", commas(direct / 100).c_str(),
                commas((base + direct) / 100).c_str(), direct * 100 / (base + direct));
    std::printf("  serving photos through a CDN:           $%s egress, $%s in total\n", commas(viaCDN / 100).c_str(),
                commas((base + viaCDN) / 100).c_str());
}

int main() {
    authz();
    otp();
    cost();
}