Semantic Designs can construct custom obfuscators for virtually any source language as a part of the corresponding Source Formatter. This page contains Ada sample code, its obfuscated version, and the generated obfuscation map.

Ada Sample Code before Obfuscation


-- Creation :  8-JUN-1988

with Stacks,

package body Directed_Graph_Operations is

   procedure Graph_Traversal (From      : in Vertex;
                              In_Graph  : in Graph;
                              Order     : in Graph_Traversal_Order;
                              Direction : in Graph_Traversal_Direction) is

         type Vertex_Storage is limited private;
         with procedure Store (Item : in Vertex; Into : in out Vertex_Storage);
         with procedure Retrieve (From : in out Vertex_Storage; Item : out Vertex);
         with function Empty (Storage : Vertex_Storage) return Boolean is <>;
         with procedure Destroy (Storage : in out Vertex_Storage) is <>;
      procedure Graph_Traversal;

      procedure Graph_Traversal is

         Waiting_Vertices : Vertex_Storage;
         Marked_Vertices  : Vertex_Set;
         V                : Vertex;

         function Adjacent (V : Vertex; In_Graph : Graph) return Vertex_List is
            case Direction is
               when Forward =>
                  return Succ(V, In_Graph);
               when Backward =>
                  return Pred(V, In_Graph);
            end case;
         end Adjacent;

         use Set_Of_Vertex;

         Add(From, To => Marked_Vertices);
         Store(From, Into => Waiting_Vertices);
         while not Empty(Waiting_Vertices) loop
            Retrieve(Item => V, From => Waiting_Vertices);
               when others =>

               Adjacent_To_V : constant Vertex_List := Adjacent(V, In_Graph);

               for I in Adjacent_To_V'Range loop
                  if not Member(Adjacent_To_V(I), Marked_Vertices) then
                     Add(Adjacent_To_V(I), To => Marked_Vertices);
                     Store(Adjacent_To_V(I), Into => Waiting_Vertices);
                  end if;
               end loop;
         end loop;
      end Graph_Traversal;

      case Order is
         when Depth_First =>

               package Vertex_Stacks is new Stacks(Vertex, Count => Natural);

               procedure Traverse_Depth_First is new Graph_Traversal(Vertex_Storage => Vertex_Stacks.Stack,
                                                                     Store          => Vertex_Stacks.Push,
                                                                     Retrieve       => Vertex_Stacks.Pop,
                                                                     Empty          => Vertex_Stacks.Empty,
                                                                     Destroy        => Vertex_Stacks.Destroy);

         when Breadth_First =>

               package Vertex_Queues is new Queues(Vertex, Count => Natural);

               procedure Traverse_Breadth_First is new Graph_Traversal(Vertex_Storage => Vertex_Queues.Queue,
                                                                       Store          => Vertex_Queues.Put,
                                                                       Retrieve       => Vertex_Queues.Get,
                                                                       Empty          => Vertex_Queues.Empty,
                                                                       Destroy        => Vertex_Queues.Destroy);

      end case;
   end Graph_Traversal;

end Directed_Graph_Operations;

Ada Code after Obfuscation

(You may need to use your horizontal scroll bar to see it completely). Notice that comments are gone, names have been scrambled, and whitespace has been garbled. Larger constants (none in this example) have their radix twiddled. The obfuscator uses special lists provided by the user to define names that should be preserved, ensuring that public interfaces and accesses to standard packages and public libraries remain valid; we didn't take advantage of that here. If you obfuscate a set of Ada source files simultaneously, only the public symbols they collectively offer will be visible in the compiled source files. An SD-supplied list covers the Standard Ada packages.

with l0,O0; package body l1 is
            procedure O1(l2: in O2; l3: in O3; l4: in O4; l5: in O5) is
            generic type l6 is limited private; with procedure O6(l7: in O2; O7: in out l6); with procedure l8(l2: in out l6; l7: out O2); with function O8(l9: l6) return
Boolean is <>; with procedure O9(l9: in out l6) is <>; procedure O1;
            procedure O1 is
            la: l6;
            Oa: lb;
            Ob: O2;
            function lc(Ob: O2; l3: O3) return Oc is
            case l5 is when ld => return Od(Ob,l3);
                       when le => return Oe(Ob,l3); end case; end lc;
            use lf; begin
            Of(l2,lg => Oa);
            O6(l2,O7 => la);
            while not O8(la) loop l8(l7 => Ob,l2 => la);
                                  begin Og(Ob); exception when others => O9(la);
                                                                         raise; end;
                                  declare lh: constant Oc := lc(Ob,l3); begin for Oh in lh'Range loop if not li(lh(Oh),Oa) then Of(lh(Oh),lg => Oa);
                                                                                                                                O6(lh(Oh),O7 => la); end if; end loop; end;
end loop;
            O8(Oa); end O1; begin
            case l4 is when Oi => declare package lj is new l0(O2,Oj => lk);
                                          procedure Ok is new O1(l6 => lj.ll,O6 => lj.Ol,l8 => lj.lm,O8 => lj.O8,O9 => lj.O9); begin Ok; end;
                       when Om => declare package ln is new O0(O2,Oj => lk);
                                          procedure On is new O1(l6 => ln.lo,O6 => ln.Oo,l8 => ln.lp,O8 => ln.O8,O9 => ln.O9); begin On; end; end case; end O1; end l1;

Obfuscated Symbol Cross Reference

The obfuscator produces a cross reference mapping obfuscated symbols to the orginal symbols, so that obfuscated code in the field can still be decoded if necessary. In fact, by reversing this map, the obfuscator can unobfuscate the code (of course, it cannot restore the comments).

### Obfuscated Identifiers ###
Action -> Og
Add -> Of
Adjacent -> lc
Adjacent_To_V -> lh
Backward -> le
Breadth_First -> Om
Count -> Oj
Depth_First -> Oi
Destroy -> O9
Directed_Graph_Operations -> l1
Direction -> l5
Empty -> O8
Forward -> ld
From -> l2
Get -> lp
Graph -> O3
Graph_Traversal -> O1
Graph_Traversal_Direction -> O5
Graph_Traversal_Order -> O4
I -> Oh
In_Graph -> l3
Into -> O7
Item -> l7
Marked_Vertices -> Oa
Member -> li
Natural -> lk
Order -> l4
Pop -> lm
Pred -> Oe
Push -> Ol
Put -> Oo
Queue -> lo
Queues -> O0
Retrieve -> l8
Set_Of_Vertex -> lf
Stack -> ll
Stacks -> l0
Storage -> l9
Store -> O6
Succ -> Od
To -> lg
Traverse_Breadth_First -> On
Traverse_Depth_First -> Ok
V -> Ob
Vertex -> O2
Vertex_List -> Oc
Vertex_Queues -> ln
Vertex_Set -> lb
Vertex_Stacks -> lj
Vertex_Storage -> l6
Waiting_Vertices -> la

For more information:    Follow us at Twitter: @SemanticDesigns

Ada Obfuscation