Video on Ciphers.py

from manim import *
import string
import random

random.seed(513)

def gen_text(text = string.ascii_uppercase):
    b = VGroup()
    lr = None
    for x in text:
        t = Text(x).set_fill(RED)
        r = Square(1)
        t.scale_to_fit_height(0.7)
        
        if lr:
            r.next_to(lr, buff=0)
        t.move_to(r.get_center())
        lr = r
        c = VGroup(t, r)
        b.add(c)
    
    b.scale_to_fit_width(len(text)*14/26)
    b.center()
    return b

def ceaser_cipher(t, k):
    s = string.ascii_uppercase
    nt = ""
    for char in t:
        i = s.index(char)
        i -= k
        i %= len(s)
        nt += s[i]
    return nt

def interpolate(a, b, t):
    t2 = 1-t
    return (a[0]*t2 + b[0]*t, a[1]*t2 + b[1]*t, a[2]*t2 + b[2]*t,)

def quad(a, b, c, t):
    p1 = interpolate(a, b, t)
    p2 = interpolate(b, c, t)
    p3 = interpolate(p1, p2, t)
    return p3

def cubic(a, b, c, d, t):
    p1 = quad(a, b, c, t)
    p2 = quad(b, c, d, t)
    p3 = interpolate(p1, p2, t)
    return p3

class Scene1(Scene):
    def construct(self):
        """
        First and foremost, we have ceaser cipher, this involves in taking two strips of the ABC alphabets and a numerical key.
        The two strips are placed one above the other and then, the strip below is shifted by the said number of places as 
        indicated by the key. Then, going over letter by letter over this mapping, we get our ciphertext. This cipher
        is increadibly weak against both modern and old techniques, since breaking this only requires testing out all values
        of the key. Only 26 combinations of the key are feasable since rotating past that would result in the same key.

        The invention of this cipher is accredited to Julius Ceaser and dates back into the 1500s, this was used as a means
        to transfer information secretly amongst armies or political associations back then.
        """
        self.next_section("Intro")
        text = Text("Ciphers", font_size=144)
        self.play(Write(text))
        self.play(text.animate.scale_to_fit_height(0.5).to_edge(UP))

        text2 = Text("Ceaser Ciphers").move_to(text.get_center())

        self.play(Transform(text, text2))

        self.next_section("Ceaser Ciphers")
        
        text2 = Text("""\
Ceaser cipher is the technique of
transposing elements from A-Z
by a certain integer key forward
or backward""")

        self.play(Write(text2))
        self.wait(4)
        self.play(FadeOut(text2, scale=1.5))


        formulae = MathTex(r"E_n (x) = (x+k) \mod 26").next_to(text, DOWN)
        self.play(Write(formulae))

        original_grid = gen_text().shift(UP)
        secondary_grid = gen_text().shift(DOWN)

        self.play(LaggedStart(Write(original_grid), Write(secondary_grid), lag_ratio=0.2))

        arrows = VGroup()
        for x in range(len(string.ascii_uppercase)):
            arrows.add(Line(start=original_grid[x].get_bottom(), end=secondary_grid[x].get_top()).add_tip(tip_length=0.2).set_opacity(0.8))
        
        self.play(Write(arrows))

        text2 = MathTex("k=")
        decimal_counter = DecimalNumber(0, num_decimal_places=0).to_edge(UR)
        text2.add_updater(lambda x: x.next_to(decimal_counter, LEFT))

        self.play(FadeIn(text2, decimal_counter))
        self.wait()

        text_to_transform = "JASMINE"

        text3 = MarkupText(f"Text: <span foreground='red'>{text_to_transform}</span>").next_to(secondary_grid, DOWN, buff=1)
        self.play(FadeIn(text3))

        text3_right = text3.get_right()
        text4_gen = lambda k: MarkupText(f"Text: <span foreground='{'red' if k==0 else 'green'}'>{ceaser_cipher(text_to_transform, k)}</span>").next_to(secondary_grid, DOWN, buff=1).move_to(text3_right).shift(RIGHT*2)
        text4 = text4_gen(0)

        self.play(text3.animate.shift(LEFT*4), FadeIn(text4))

        k = 0

        for x in range(26):
            k += 1
            decimal_counter.set_value(k)
            self.play(secondary_grid[-k].animate.next_to(secondary_grid.get_left(), LEFT, buff=0), run_time=1 if x<5 else 0.25)
            self.play(secondary_grid.animate.shift(RIGHT*secondary_grid[-k].width), run_time=1 if x<5 else 0.25)

            nums = []
            for i, char in enumerate(text_to_transform):
                arr_index = string.ascii_uppercase.index(char)
                nums.append(Text(str(i), font_size=20).next_to(arrows[arr_index], DOWN, buff=secondary_grid.height + 0.2))
                self.play(arrows[arr_index].animate.set_color(GREEN), FadeIn(nums[-1]), run_time=0.2 if x<5 else 0.05)

            self.play(Transform(text4, text4_gen(k)), run_time=1 if x<5 else 0.25)

            self.play(*(arrows[string.ascii_uppercase.index(char)].animate.set_color(WHITE) for char in text_to_transform), *(FadeOut(x) for x in nums), run_time=0.2 if x<5 else 0.05)
        
class Scene11(Scene):
    def construct(self):
        
        txt = VGroup(Text("Invented by Julius Ceaser", font_size=50), Text("between 100BC to 44BC", fill_opacity=0.9, font_size=30)).arrange_submobjects(DOWN).to_edge(buff=1)
        im = ImageMobject("assets/julius.jpg").scale_to_fit_height(3).next_to(txt, RIGHT, 1)
        
        self.play(Write(txt), FadeIn(im))
        self.wait()

class Scene2(Scene):
    def construct(self):
        """
        Next, we have substitution cipher, this involves in both the parties knowing a fixed sized key
        of length 26, This key is used as a mapping to both encrypt and decrypt the information involved.

        Here, we take the initial text jasmine, and then by meticulously going letter by letter
        replacing it with the said key mapping, we obtain our ciphertext, which is much more secure
        than the previous technique though still easy to crack by the modern standard using computers

        The invention of this cipher is credited to Al'Kindi during the 9th century.
        """
        self.next_section("Substitution Ciphers")
        text = Text("Ciphers", font_size=144).scale_to_fit_height(0.5).to_edge(UP)
        text2 = Text("Substitution Ciphers").move_to(text.get_center())
        self.play(Write(text2))
        
        text2 = Text("""\
Substitution Cipher essentially takes a 26
alphabet key and substitutes the elements
according to that!""")
        self.play(Write(text2))
        self.wait(4)
        self.play(FadeOut(text2, scale=1.5))

        key = list(string.ascii_uppercase)
        random.shuffle(key)
        key = ''.join(key)

        formulae = MathTex("E_n (x) = k(x)").next_to(text, DOWN)
        self.play(Write(formulae))

        original_grid = gen_text().shift(UP)
        secondary_grid = gen_text(key).shift(DOWN)

        text3 = Text("key", font_size=30).next_to(secondary_grid, DOWN, aligned_edge=LEFT, buff=0.5)

        self.play(LaggedStart(Write(original_grid), Write(secondary_grid), Write(text3), lag_ratio=0.2))

        arrows = VGroup()
        for x in range(len(string.ascii_uppercase)):
            arrows.add(Line(start=original_grid[x].get_bottom(), end=secondary_grid[x].get_top()).add_tip(tip_length=0.2).set_opacity(0.8))
        
        self.play(Write(arrows))
        
        t = "JASMINE"
        t2 = ""
        for x in t:
            t2 += key[string.ascii_uppercase.index(x)]

        text4 = Text(t, color=RED).to_corner(DL, buff=1)
        self.play(Write(text4), run_time=0.5)

        for i, char in enumerate(t):
            arr_index = string.ascii_uppercase.index(char)
            self.play(arrows[arr_index].animate.set_color(GREEN), FadeIn(Text(str(i), font_size=20).next_to(arrows[arr_index], DOWN, buff=secondary_grid.height + 0.2)), run_time=0.5)

        text5 = Text(t2, color=GREEN).to_corner(DR, buff=1)
        arrow = Line(text4.get_right()+RIGHT, text5.get_left()+LEFT).add_tip()

        self.play(Write(text5), Create(arrow), run_time=1)
        self.wait(3)


class Scene21(Scene):
    def construct(self):
        
        txt = VGroup(Text("Invented by Al'Kindi", font_size=50), Text("between 801AD to 873AD", fill_opacity=0.9, font_size=30)).arrange_submobjects(DOWN).to_edge(buff=1)
        im = ImageMobject("assets/alkindi.jpg").scale_to_fit_height(3).next_to(txt, RIGHT, 1)
        
        self.play(Write(txt), FadeIn(im))
        self.wait()


class IntroScene(Scene):
    def construct(self):
        """When we talk, chat, or browse the internet, we come across many bad actors, aka, people really interested in your personal information.
        To mitigate this, some smart people dating as far back as 50BC invented cryptography and ciphers to encrypt your messages and to transfer
        them securely over any medium, from the paper back in the 1500s, now to the electronic transfer of data via Internet and Radio, everything
        involves cryptography. Today, we'll look into some of the first cryptographic functions with the help of animations!"""
        im = SVGMobject("assets/inet.svg").scale_to_fit_height(6).center().set_fill(WHITE)

        self.play(Write(im), run_time=4)
        self.wait(0.4)
        self.play(im.animate.scale(0.5).to_edge(LEFT, 1))

        diagram = VGroup(
            SVGMobject("assets/man-person-icon.svg").set_fill(WHITE).scale_to_fit_height(1),
            Line().set_length(3).add_tip(),
            SVGMobject("assets/man-person-icon.svg").set_fill(WHITE).scale_to_fit_height(1),
        ).arrange_submobjects(RIGHT).shift(RIGHT)

        self.play(Write(diagram), run_time=3)
        self.play(diagram.animate.to_edge(RIGHT, 1))

        hacker_im = SVGMobject("assets/crime-hacker-icon.svg").scale_to_fit_height(2.5).center().set_fill(WHITE).shift(LEFT*0.8)

        self.play(Write(hacker_im))

        self.play(hacker_im.animate.scale_to_fit_height(1), run_time=0.5)
        self.play(MoveAlongPath(hacker_im, ParametricFunction(lambda t: cubic(hacker_im.get_center(), hacker_im.get_center()+DOWN*2, (1, -2, 0), (5, -2, 0), t))))

        unsafe_icon = SVGMobject("assets/unsafe-icon.svg").scale_to_fit_height(0.7).move_to(diagram[1])
        txt = Text("Unencrypted Communication", slant=ITALIC, font_size=30).next_to(diagram, DOWN).shift(RIGHT*0.2)

        self.play(FadeOut(diagram[2]), hacker_im.animate.move_to(diagram[2].get_center()).shift(RIGHT*0.2), Write(unsafe_icon), Write(txt))
        
        self.wait()

        self.play(*(FadeOut(x) for x in self.mobjects))

        txt = Text("Ciphers", font_size=144)
        self.play(Write(txt))

        container_rect = RoundedRectangle(0.5, height = 2.5, width = 8, fill_color=WHITE, fill_opacity=1).next_to(txt, DOWN, buff=-0.75)

        paper = SVGMobject("assets/paper.svg").scale_to_fit_height(2).next_to(txt, DOWN, buff=-0.5)
        ineticon = SVGMobject("assets/ineticon.svg").scale_to_fit_height(2).next_to(txt, DOWN, buff=-0.5)
        self.play(FadeIn(container_rect), Write(paper), txt.animate.shift(UP))
        self.play(paper.animate.to_edge(LEFT, 4))
        self.play(Write(ineticon))
        self.play(ineticon.animate.to_edge(RIGHT, 4))

        contained_items = VGroup(container_rect, paper, ineticon)
        self.play(FadeOut(contained_items, scale=1.5), txt.animate.center())

        self.wait(5)


class Scene3(Scene):
    """
    Next we shall be looking over a cipher that stood the test of time
    for a whole 3 centuries before it was uncovered! Named after Blaise
    de Vigenere, though it was initially discovered by Saint-Pourçain-sur-Sioule.

    This cipher is essentially a more complex variant of ceaser cipher
    where each letter in the alphabet is assigned numbers 1 through 26.
    Then, the given key is repeated up until the length of the input text
    then, iterating over this, the key's corresponding index to the text's
    corresponding index is taken. The key's numerical value is then used
    as input to ceaser's cipher and a resultant ciphertext value comes for
    the said text character!

    Though this method is pretty strong to be breakable by hand, it
    still is cryptographically weak against the modern standard such as
    AES-256.

    That being said, it was discovered in the 16th century!
    """
    def construct(self):
        self.next_section("Vigenère Ciphers")
        text = Text("Ciphers", font_size=144).scale_to_fit_height(0.5).to_edge(UP)
        text2 = Text("Vigenère Ciphers").move_to(text.get_center())
        self.play(Write(text2))
        
        text2 = Text("""\
Vigenère Cipher essentially takes a n-length
alphabet key and using the n-th element's numeric
value in the alphabet performs a ceaser cipher
with the said numeric value for the n-th letter of
the input.""").scale_to_fit_width(14)
        self.play(Write(text2))
        self.wait(4)
        self.play(FadeOut(text2, scale=1.5))

        key = list(string.ascii_uppercase)
        random.shuffle(key)
        key = ''.join(key)

        formulae = MathTex(r"E_k (X_i) = (X_i + K_i) \mod 26").next_to(text, DOWN)
        self.play(Write(formulae))

        t = "JASMINE"

        orig_grid = gen_text("JASMINE").arrange_submobjects(DOWN, buff=0).center().to_edge(LEFT).shift(DOWN*1)
        
        for i, x in enumerate(orig_grid):
            num = Text(str(i+1), font_size=20)
            num.next_to(x, RIGHT, buff=0.1)
            x.add(num)


        key_txt = Text("key").scale_to_fit_width(orig_grid.width).next_to(orig_grid, UP)

        self.play(Write(orig_grid), Write(key_txt))

        cipherwheelout = gen_text(string.ascii_uppercase).scale_to_fit_width(10)
        cipherwheelin = gen_text(string.ascii_uppercase).next_to(cipherwheelout, DOWN).scale_to_fit_width(10)

        wheelheights = cipherwheelout.height*1.5

        self.play(LaggedStart(Write(cipherwheelin), Write(cipherwheelout)))
        self.play(cipherwheelin.animate.apply_function(
            rotate_point(cipherwheelin, 3-wheelheights, 1.5)
        ).move_to(ORIGIN+DOWN), 

        cipherwheelout.animate.apply_function(
            rotate_point(cipherwheelout, 3, 1.5)
        ).move_to(ORIGIN+DOWN), run_time=5)

        cipherwheelgroup = VGroup(cipherwheelout)
        self.remove(cipherwheelin)

        theta = ValueTracker(0)

        cipherwheelin_updated = always_redraw(lambda: cipherwheelin.copy().rotate(theta.get_value()))
        self.add(cipherwheelin_updated)

        center_dot = Dot(cipherwheelgroup.get_center(), 0.1)
        line1 = Line(start=cipherwheelgroup.get_center(), end=cipherwheelin.get_top()-np.array([0, wheelheights, 0]), color=RED)
        line2 = always_redraw(lambda: Line(start=cipherwheelgroup.get_center(), end=cipherwheelin.get_top()-np.array([0, wheelheights, 0]), color=GREEN).rotate(theta.get_value(), about_point=cipherwheelgroup.get_center()))

        key_grp = VGroup(
            MathTex("key ="), (current_key := DecimalNumber(num_decimal_places=0))
        ).arrange_submobjects(RIGHT).scale_to_fit_width(cipherwheelin.get_top()[1] - wheelheights).next_to(center_dot, RIGHT)

        cipherwheelgroup.add(line1, center_dot, line2, cipherwheelin_updated, key_grp)
        self.play(Create(center_dot), Write(line1), Write(line2), Write(key_grp))
        
        kd = -2*PI/26

        current_key.add_updater(lambda t: t.set_value(theta.get_value()//kd))

        text_to_encrypt = "SOMESUPERBTEXT"
        encrypted_text = [" "]*len(text_to_encrypt)
        txt = gen_text(text_to_encrypt).arrange_submobjects(DOWN, 0).scale_to_fit_height(7).next_to(np.array([cipherwheelgroup.get_right()[0], 0, 0]), RIGHT, 2)

        def __t():
            return gen_text("".join(encrypted_text)).arrange_submobjects(DOWN, 0).scale_to_fit_height(7).next_to(txt, RIGHT)

        txt2 = __t()
        self.play(LaggedStart(Write(txt), Write(txt2), lag_ratio=0.2))
        
        arrow = Line().set_length(1).add_tip(tip_length=0.1, tip_width=0.1).rotate(PI)
        arrow.next_to(orig_grid[0])

        arrow2 = Line().set_length(1).add_tip(tip_length=0.1, tip_width=0.1)
        arrow2.next_to(txt[0], LEFT)

        self.play(Write(arrow), Write(arrow2))

        kp = 0  # Key Position
        tp = 0  # Text Position
        for x in text_to_encrypt:
            _k = string.ascii_uppercase.index(t[kp])
            _t = string.ascii_uppercase.index(x)

            
            encrypted_text[tp] = string.ascii_uppercase[(_t - _k)%26]
            self.play(theta.animate.set_value(_k*kd), arrow.animate.next_to(orig_grid[kp]), arrow2.animate.next_to(txt[tp], LEFT), run_time=1)
            self.play(Transform(txt2, __t()))

            kp += 1 
            kp %= len(t)
            tp += 1

        self.play(theta.animate.set_value(0))

class Scene31(Scene):
    def construct(self):
        
        txt = VGroup(Text("Invented by Saint-Pourçain-sur-Sioule", font_size=50), Text("between 1523AD to 1596AD", fill_opacity=0.9, font_size=30), Text("Falsely accredited to Blaise de Vigenère", fill_opacity=0.9, font_size=30)).arrange_submobjects(DOWN).to_edge(buff=1).scale_to_fit_width(8)
        im = ImageMobject("assets/vigenere.png").scale_to_fit_height(3).next_to(txt, RIGHT, 0.7)
        
        self.play(Write(txt), FadeIn(im))
        self.wait()

def rotate_point(mobj: VMobject, init_r=2, scale=1):
    t_w = mobj.width
    x_pos = mobj.get_left()[0]
    y_pos = mobj.get_top()[1]

    def rot(p):
        r = (p[1] - y_pos)*scale + init_r
        theta = (-(p[0] - x_pos)*2*PI/t_w) + (PI/2)

        x = r*np.cos(theta) + x_pos
        y = r*np.sin(theta) + y_pos*scale - init_r

        return np.array([x, y, p[2]])
    
    return rot


class Outro(Scene):
    """
    That would be all for now, today, we learnt about the ceaser's cipher, the substitution cipher
    and the vigenere cipher. This video was programmatically created using Manim Library and Python.

    Looking forward to a victory, now tuning off, Amaan from Team Jasmine!
    """
    def construct(self):
        banner = ManimBanner()
        self.play(banner.create())
        self.play(banner.expand())
        self.wait()

        self.play(Unwrite(banner))

        pylogo = ImageMobject("assets/python-3.png").scale_to_fit_width(12)

        self.play(FadeIn(pylogo))
        self.wait()

        self.play(FadeOut(pylogo))

        t = VGroup(
            Text("Thank You", font_size=140),
            Text("By Amaan Khan, 12-A", font_size=60, slant=ITALIC),
            Text("Jasmine", color=RED)
        ).arrange_submobjects(DOWN)

        self.play(Write(t), run_time=2)

        self.wait()

        

Woah. respect. This is really great. 🎖️