├── csVersion
    ├── build.bat
    ├── PlgxExtractor.exe
    └── PlgxExtractor.cs
├── README.md
├── linqVersion
    └── PlgxExtractor.linq
├── psVersion
    └── PlgxExtractor.ps1
└── LICENSE


/csVersion/build.bat:
--------------------------------------------------------------------------------
1 | @echo off
2 | "%windir%\Microsoft.NET\Framework\v4.0.30319\csc" PlgxExtractor.cs
3 | pause


--------------------------------------------------------------------------------
/csVersion/PlgxExtractor.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Geograph-us/PlgxExtractor/HEAD/csVersion/PlgxExtractor.exe


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # PlgxExtractor
2 | ### KeePass Plugins Unpacker
3 | 
4 | Extract files from KeePass v2.xx PLGX-files
5 | 
6 | Dirty implementation does not handle format structure carefully.
7 | 
8 | Three C# versions: LinqPad, PowerShell, Native C# + binary file
9 | 


--------------------------------------------------------------------------------
/linqVersion/PlgxExtractor.linq:
--------------------------------------------------------------------------------
  1 | <Query Kind="Program">
  2 |   <Namespace>System.IO.Compression</Namespace>
  3 | </Query>
  4 | 
  5 | string LastError = "\r\n";
  6 | 
  7 | void Main()
  8 | {
  9 | 	var files = Directory.GetFiles(".", "*.plgx").ToList();
 10 | 	Console.WriteLine("Select PLGX-files to extract (comma separated):");
 11 | 	Console.WriteLine("0 - All");
 12 | 	for (int i = 0; i < files.Count; i++)
 13 | 	{
 14 | 		Console.WriteLine((i + 1).ToString() + " - " + files[i]);
 15 | 	}
 16 | 	var choice = Console.ReadLine();
 17 | 	Console.WriteLine();
 18 | 
 19 | 	var choices = choice.Split(',').Select(int.Parse);
 20 | 	if (!choices.Contains(0)) files = files.Where((x, i) => choices.Contains(i + 1)).ToList();
 21 | 
 22 | 	for (int i = 0; i < files.Count; i++)
 23 | 	{
 24 | 		Extract(files[i]);
 25 | 	}
 26 | 
 27 | 	Console.Write(LastError);
 28 | 
 29 | 	Console.Write("Press Enter to exit...");
 30 | 	Console.ReadLine();
 31 | }
 32 | 
 33 | void Extract(string filename)
 34 | {
 35 | 	var filesBeginPattern = BitConverter.GetBytes(0x0004000000000003);
 36 | 	var dirname = Path.GetFileNameWithoutExtension(filename);
 37 | 	Console.Write("[" + filename + "] ");
 38 | 
 39 | 	using (var fs = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.Read))
 40 | 	{		
 41 | 		using (var br = new BinaryReader(fs))
 42 | 		{			
 43 | 			if (br.ReadInt32() != 0x65d90719)
 44 | 			{
 45 | 				Console.WriteLine("ERROR: not PLGX-file");
 46 | 				LastError += "ERROR: not PLGX-file " + filename + "\r\n";
 47 | 				return;
 48 | 			}
 49 | 			// Plugin-name
 50 | 			fs.Position = 0x24;
 51 | 			var size = br.ReadInt32();
 52 | 			var value = br.ReadBytes(size);
 53 | 			var plugName = Encoding.Default.GetString(value);
 54 | 
 55 | 			// Plugin creation date
 56 | 			fs.Position += 2;
 57 | 			size = br.ReadInt32();
 58 | 			value = br.ReadBytes(size);
 59 | 			var date = DateTime.Parse(Encoding.Default.GetString(value));
 60 | 
 61 | 			// Plugin creation tool
 62 | 			fs.Position += 2;
 63 | 			size = br.ReadInt32();
 64 | 			value = br.ReadBytes(size);
 65 | 			var creationToolName = Encoding.Default.GetString(value);
 66 | 			Console.WriteLine("[" + plugName + "] [" + date.ToString() + "] [" + creationToolName + "]");
 67 | 
 68 | 			// Go to files list
 69 | 			var bytesCount = 500;
 70 | 			var filesBegin = Search(br.ReadBytes(bytesCount), filesBeginPattern);
 71 | 
 72 | 			if (filesBegin == -1)
 73 | 			{
 74 | 				Console.WriteLine("ERROR: files list not found");
 75 | 				LastError += "ERROR: files list not found " + filename + "\r\n";
 76 | 				return;
 77 | 			}
 78 | 
 79 | 			fs.Position = fs.Position - bytesCount + filesBegin + 14;
 80 | 
 81 | 			var isOk = true;
 82 | 			while (true)
 83 | 			{
 84 | 				size = br.ReadInt32();
 85 | 				if (size < 1) break;
 86 | 				value = br.ReadBytes(size);
 87 | 
 88 | 				// filename
 89 | 				var name = Encoding.Default.GetString(value);
 90 | 				fs.Position += 2;
 91 | 
 92 | 				// gzipped file size
 93 | 				size = br.ReadInt32();
 94 | 				var buffer = GzipDecompress(br.ReadBytes(size));
 95 | 				Console.WriteLine(name + ". Compressed Size: " + size.ToString() + ". Size: " + buffer.Length);
 96 | 
 97 | 				// fix relative path
 98 | 				name = name.Replace("../", "").Replace(@"..\", "");
 99 | 				var path = Path.Combine(dirname, name);
100 | 				var folder = Path.GetDirectoryName(path);
101 | 				if (!Directory.Exists(folder)) Directory.CreateDirectory(folder);
102 | 				if (buffer.Length > 0 || size == 0) File.WriteAllBytes(path, buffer);
103 | 				else
104 | 				{
105 | 					Console.WriteLine("Can't Extract File: " + name);
106 | 					isOk = false;
107 | 				}
108 | 
109 | 				fs.Position += 14;
110 | 			}
111 | 
112 | 			if (!isOk) LastError += "ERROR: not all files was extracted " + filename + "\r\n";
113 | 		}
114 | 	}
115 | 	Console.WriteLine("Extracted!");
116 | 	Console.WriteLine();
117 | }
118 | 
119 | int Search(byte[] sIn, byte[] sFor)
120 | {
121 | 	int[] numArray = new int[256];
122 | 	int num1 = 0;
123 | 	int num2 = sFor.Length - 1;
124 | 	for (int index = 0; index < 256; ++index) numArray[index] = sFor.Length;
125 | 	for (int index = 0; index < num2; ++index) numArray[(int)sFor[index]] = num2 - index;
126 | 	while (num1 <= sIn.Length - sFor.Length)
127 | 	{
128 | 		for (int index = num2; (int)sIn[num1 + index] == (int)sFor[index]; --index)
129 | 		{
130 | 			if (index == 0) return num1;
131 | 		}
132 | 		num1 += numArray[(int)sIn[num1 + num2]];
133 | 	}
134 | 	return -1;
135 | }
136 | 
137 | byte[] GzipDecompress(byte[] data)
138 | {
139 | 	byte[] decompressedArray = null;
140 | 	try
141 | 	{
142 | 		using (MemoryStream decompressedStream = new MemoryStream())
143 | 		{
144 | 			using (MemoryStream compressStream = new MemoryStream(data))
145 | 			{
146 | 				using (var deflateStream = new GZipStream(compressStream, CompressionMode.Decompress))
147 | 				{
148 | 					deflateStream.CopyTo(decompressedStream);
149 | 				}
150 | 			}
151 | 			decompressedArray = decompressedStream.ToArray();
152 | 		}
153 | 	}
154 | 	catch (Exception exception)
155 | 	{
156 | 		Console.WriteLine(exception.Message);
157 | 	}
158 | 	return decompressedArray;
159 | }
160 | 


--------------------------------------------------------------------------------
/psVersion/PlgxExtractor.ps1:
--------------------------------------------------------------------------------
  1 | using namespace System.Text
  2 | using namespace System.Linq
  3 | using namespace System.IO
  4 | using namespace System.IO.Compression
  5 | 
  6 | function Extract($filename)
  7 | {
  8 |   $filesBeginPattern = [BitConverter]::GetBytes(0x0004000000000003)
  9 |   $dirname = $filename.BaseName
 10 |   Write-Host -NoNewline "[$($filename.Name)] "
 11 | 
 12 |   $fs = [File]::Open($filename, [FileMode]::Open, [FileAccess]::Read, [FileShare]::Read)      
 13 |   $br = New-Object BinaryReader($fs)
 14 |     
 15 |   if ($br.ReadInt32() -ne 0x65d90719)
 16 |   {
 17 |     Write-Host "ERROR: not PLGX-file"
 18 |     $global:LastError += "ERROR: not PLGX-file " + $filename + "`r`n"
 19 |     return
 20 |   }
 21 |   # Plugin-name
 22 |   $fs.Position = 0x24
 23 |   $size = $br.ReadInt32()
 24 |   $value = $br.ReadBytes($size)
 25 |   $plugName = $enc.GetString($value)
 26 | 
 27 |   # Plugin creation date
 28 |   $fs.Position += 2
 29 |   $size = $br.ReadInt32()
 30 |   $value = $br.ReadBytes($size)
 31 |   $date = [DateTime]::Parse($enc.GetString($value))
 32 | 
 33 |   # Plugin creation tool
 34 |   $fs.Position += 2
 35 |   $size = $br.ReadInt32()
 36 |   $value = $br.ReadBytes($size)
 37 |   $creationToolName = $enc.GetString($value)
 38 |   Write-Host "[$($plugName)] [$($date)] [$($creationToolName)]"
 39 | 
 40 |   # Go to files list
 41 |   $bytesCount = 500
 42 |   $filesBegin = Search $br.ReadBytes($bytesCount) $filesBeginPattern
 43 | 
 44 |   if ($filesBegin -eq -1)
 45 |   {
 46 |     Write-Host "ERROR: files list not found"
 47 |     $global:LastError += "ERROR: files list not found " + $filename + "`r`n"
 48 |     return
 49 |   }
 50 | 
 51 |   $fs.Position = $fs.Position - $bytesCount + $filesBegin + 14
 52 | 
 53 |   $isOk = $true
 54 |   while ($true)
 55 |   {
 56 |     $size = $br.ReadInt32()
 57 |     if ($size -lt 1)
 58 |     {
 59 |       break
 60 |     }
 61 |     $value = $br.ReadBytes($size)
 62 | 
 63 |     # filename
 64 |     $name = $enc.GetString($value)
 65 |     $fs.Position += 2
 66 | 
 67 |     # gzipped file size
 68 |     $size = $br.ReadInt32()      
 69 |     $buffer = GzipDecompress $br.ReadBytes($size)
 70 |     Write-Host "$($name). Compressed Size: $($size). Size: $($buffer.Length)"
 71 | 
 72 |     # fix relative path
 73 |     $name = $name.Replace("../", "").Replace("..\", "")
 74 |     $path = [Path]::Combine($dirname, $name)
 75 |     $folder = [Path]::GetDirectoryName($path)
 76 |     
 77 |     if (!(Test-Path -Path $folder))
 78 |     {
 79 |       $res = New-Item -ItemType directory -Path $folder
 80 |     }
 81 |     
 82 |     if ($buffer.Length -gt 0 -or $size -eq 0)
 83 |     {
 84 |       [File]::WriteAllBytes($path, $buffer)
 85 |     }
 86 |     else
 87 |     {
 88 |       Write-Host "Can't Extract File: $($name)"
 89 |       $isOk = $false
 90 |     }
 91 | 
 92 |     $fs.Position += 14
 93 |   }
 94 |   $br.Close()
 95 |   $fs.Close()      
 96 | 
 97 |   if (!$isOk)
 98 |   {
 99 |     $global:LastError += "ERROR: not all files was extracted " + $filename + "`r`n"
100 |   }
101 |   
102 |   Write-Host "Extracted!"
103 |   Write-Host ""
104 | }
105 | 
106 | function Search($sIn, $sFor)
107 | {	
108 |   $numArray = New-Object int[] 256
109 |   $num1 = 0
110 |   $num2 = $sFor.Length - 1
111 |   for ($index = 0; $index -lt 256; ++$index)
112 |   {
113 |     $numArray[$index] = $sFor.Length
114 |   }
115 |   for ($index = 0; $index -lt $num2; ++$index)
116 |   {
117 |     $numArray[$sFor[$index]] = $num2 - $index
118 |   }
119 |   while ($num1 -le $sIn.Length - $sFor.Length)
120 |   {
121 |     for ($index = $num2; $sIn[$num1 + $index] -eq $sFor[$index]; --$index)
122 |     {
123 |       if ($index -eq 0)
124 |       {
125 |         return $num1
126 |       }
127 |     }
128 |     $num1 += $numArray[$sIn[$num1 + $num2]]
129 |   }
130 |   return -1
131 | }
132 | 
133 | function GzipDecompress($data)
134 | {
135 |   if ($data.Length -lt 1)
136 |   {
137 |     return New-Object byte[] 0
138 |   }
139 |   $decompressedStream = New-Object MemoryStream
140 |   $compressStream = New-Object MemoryStream(,$data)
141 |   $deflateStream = New-Object GzipStream $compressStream, ([CompressionMode]::Decompress)
142 |   $deflateStream.CopyTo($decompressedStream)
143 |   $deflateStream.Close()
144 |   $compressStream.Close()
145 |   $decompressedArray = $decompressedStream.ToArray()
146 |   return $decompressedArray
147 | }
148 | 
149 | $global:LastError = "`r`n"
150 | $enc = [Encoding]::Default
151 | 
152 | $files = Get-ChildItem *.plgx
153 |   
154 | Write-Host "Select PLGX-files to extract (comma separated):"
155 | Write-Host "0 - All"
156 | for ($i = 0; $i -lt $files.Count; $i++)
157 | {
158 |   Write-Host ($i + 1).ToString() "-" $files[$i].Name
159 | }
160 | $choice = Read-Host
161 | Write-Host ""
162 | 
163 | [Array]$choices = $choice -split ',' | % { iex $_ }
164 | 
165 | if (!$choices.Contains(0))
166 | {
167 |   $files = [Enumerable]::Where($files, [Func[object,int,bool]]{ param($x,$i) $choices.Contains($i + 1) })
168 | }
169 | 
170 | for ($i = 0; $i -lt $files.Count; $i++)
171 | {
172 |   Extract $files[$i]
173 | }
174 | 
175 | Write-Host -NoNewline $global:LastError
176 | 
177 | Write-Host -NoNewline "Press Enter to exit..."
178 | Read-Host
179 | 


--------------------------------------------------------------------------------
/csVersion/PlgxExtractor.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Text;
  3 | using System.Linq;
  4 | using System.IO;
  5 | using System.IO.Compression;
  6 | 
  7 | namespace PlgxExtractor
  8 | {
  9 |     class Program
 10 |     {
 11 |         static string LastError = "\r\n";
 12 | 
 13 |         static void Main()
 14 |         {
 15 |             var files = Directory.GetFiles(".", "*.plgx").ToList();
 16 |             Console.WriteLine("Select PLGX-files to extract (comma separated):");
 17 |             Console.WriteLine("0 - All");
 18 |             for (int i = 0; i < files.Count; i++)
 19 |             {
 20 |                 Console.WriteLine((i + 1).ToString() + " - " + files[i]);
 21 |             }
 22 |             var choice = Console.ReadLine();
 23 |             Console.WriteLine();
 24 | 
 25 |             var choices = choice.Split(',').Select(int.Parse);
 26 |             if (!choices.Contains(0)) files = files.Where((x, i) => choices.Contains(i + 1)).ToList();
 27 | 
 28 |             for (int i = 0; i < files.Count; i++)
 29 |             {
 30 |                 Extract(files[i]);
 31 |             }
 32 | 
 33 |             Console.Write(LastError);
 34 | 
 35 |             Console.Write("Press Enter to exit...");
 36 |             Console.ReadLine();
 37 |         }
 38 | 
 39 |         static void Extract(string filename)
 40 |         {
 41 |             var filesBeginPattern = BitConverter.GetBytes(0x0004000000000003);
 42 |             var dirname = Path.GetFileNameWithoutExtension(filename);
 43 |             Console.Write("[" + filename + "] ");
 44 | 
 45 |             using (var fs = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.Read))
 46 |             {
 47 |                 using (var br = new BinaryReader(fs))
 48 |                 {
 49 |                     if (br.ReadInt32() != 0x65d90719)
 50 |                     {
 51 |                         Console.WriteLine("ERROR: not PLGX-file");
 52 |                         LastError += "ERROR: not PLGX-file " + filename + "\r\n";
 53 |                         return;
 54 |                     }
 55 |                     // Plugin-name
 56 |                     fs.Position = 0x24;
 57 |                     var size = br.ReadInt32();
 58 |                     var value = br.ReadBytes(size);
 59 |                     var plugName = Encoding.Default.GetString(value);
 60 | 
 61 |                     // Plugin creation date
 62 |                     fs.Position += 2;
 63 |                     size = br.ReadInt32();
 64 |                     value = br.ReadBytes(size);
 65 |                     var date = DateTime.Parse(Encoding.Default.GetString(value));
 66 | 
 67 |                     // Plugin creation tool
 68 |                     fs.Position += 2;
 69 |                     size = br.ReadInt32();
 70 |                     value = br.ReadBytes(size);
 71 |                     var creationToolName = Encoding.Default.GetString(value);
 72 |                     Console.WriteLine("[" + plugName + "] [" + date.ToString() + "] [" + creationToolName + "]");
 73 | 
 74 |                     // Go to files list
 75 |                     var bytesCount = 500;
 76 |                     var filesBegin = Search(br.ReadBytes(bytesCount), filesBeginPattern);
 77 | 
 78 |                     if (filesBegin == -1)
 79 |                     {
 80 |                         Console.WriteLine("ERROR: files list not found");
 81 |                         LastError += "ERROR: files list not found " + filename + "\r\n";
 82 |                         return;
 83 |                     }
 84 | 
 85 |                     fs.Position = fs.Position - bytesCount + filesBegin + 14;
 86 | 
 87 |                     var isOk = true;
 88 |                     while (true)
 89 |                     {
 90 |                         size = br.ReadInt32();
 91 |                         if (size < 1) break;
 92 |                         value = br.ReadBytes(size);
 93 | 
 94 |                         // filename
 95 |                         var name = Encoding.Default.GetString(value);
 96 |                         fs.Position += 2;
 97 | 
 98 |                         // gzipped file size
 99 |                         size = br.ReadInt32();
100 |                         var buffer = GzipDecompress(br.ReadBytes(size));
101 |                         Console.WriteLine(name + ". Compressed Size: " + size.ToString() + ". Size: " + buffer.Length);
102 | 
103 |                         // fix relative path
104 |                         name = name.Replace("../", "").Replace(@"..\", "");
105 |                         var path = Path.Combine(dirname, name);
106 |                         var folder = Path.GetDirectoryName(path);
107 |                         if (!Directory.Exists(folder)) Directory.CreateDirectory(folder);
108 |                         if (buffer.Length > 0 || size == 0) File.WriteAllBytes(path, buffer);
109 |                         else
110 |                         {
111 |                             Console.WriteLine("Can't Extract File: " + name);
112 |                             isOk = false;
113 |                         }
114 | 
115 |                         fs.Position += 14;
116 |                     }
117 | 
118 |                     if (!isOk) LastError += "ERROR: not all files was extracted " + filename + "\r\n";
119 |                 }
120 |             }
121 |             Console.WriteLine("Extracted!");
122 |             Console.WriteLine();
123 |         }
124 | 
125 |         static int Search(byte[] sIn, byte[] sFor)
126 |         {
127 |             int[] numArray = new int[256];
128 |             int num1 = 0;
129 |             int num2 = sFor.Length - 1;
130 |             for (int index = 0; index < 256; ++index) numArray[index] = sFor.Length;
131 |             for (int index = 0; index < num2; ++index) numArray[(int)sFor[index]] = num2 - index;
132 |             while (num1 <= sIn.Length - sFor.Length)
133 |             {
134 |                 for (int index = num2; (int)sIn[num1 + index] == (int)sFor[index]; --index)
135 |                 {
136 |                     if (index == 0) return num1;
137 |                 }
138 |                 num1 += numArray[(int)sIn[num1 + num2]];
139 |             }
140 |             return -1;
141 |         }
142 | 
143 |         static byte[] GzipDecompress(byte[] data)
144 |         {
145 |             byte[] decompressedArray = null;
146 |             try
147 |             {
148 |                 using (MemoryStream decompressedStream = new MemoryStream())
149 |                 {
150 |                     using (MemoryStream compressStream = new MemoryStream(data))
151 |                     {
152 |                         using (var deflateStream = new GZipStream(compressStream, CompressionMode.Decompress))
153 |                         {
154 |                             deflateStream.CopyTo(decompressedStream);
155 |                         }
156 |                     }
157 |                     decompressedArray = decompressedStream.ToArray();
158 |                 }
159 |             }
160 |             catch (Exception exception)
161 |             {
162 |                 Console.WriteLine(exception.Message);
163 |             }
164 |             return decompressedArray;
165 |         }
166 |     }
167 | }
168 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | Creative Commons Legal Code
  2 | 
  3 | CC0 1.0 Universal
  4 | 
  5 |     CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
  6 |     LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
  7 |     ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
  8 |     INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
  9 |     REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
 10 |     PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
 11 |     THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
 12 |     HEREUNDER.
 13 | 
 14 | Statement of Purpose
 15 | 
 16 | The laws of most jurisdictions throughout the world automatically confer
 17 | exclusive Copyright and Related Rights (defined below) upon the creator
 18 | and subsequent owner(s) (each and all, an "owner") of an original work of
 19 | authorship and/or a database (each, a "Work").
 20 | 
 21 | Certain owners wish to permanently relinquish those rights to a Work for
 22 | the purpose of contributing to a commons of creative, cultural and
 23 | scientific works ("Commons") that the public can reliably and without fear
 24 | of later claims of infringement build upon, modify, incorporate in other
 25 | works, reuse and redistribute as freely as possible in any form whatsoever
 26 | and for any purposes, including without limitation commercial purposes.
 27 | These owners may contribute to the Commons to promote the ideal of a free
 28 | culture and the further production of creative, cultural and scientific
 29 | works, or to gain reputation or greater distribution for their Work in
 30 | part through the use and efforts of others.
 31 | 
 32 | For these and/or other purposes and motivations, and without any
 33 | expectation of additional consideration or compensation, the person
 34 | associating CC0 with a Work (the "Affirmer"), to the extent that he or she
 35 | is an owner of Copyright and Related Rights in the Work, voluntarily
 36 | elects to apply CC0 to the Work and publicly distribute the Work under its
 37 | terms, with knowledge of his or her Copyright and Related Rights in the
 38 | Work and the meaning and intended legal effect of CC0 on those rights.
 39 | 
 40 | 1. Copyright and Related Rights. A Work made available under CC0 may be
 41 | protected by copyright and related or neighboring rights ("Copyright and
 42 | Related Rights"). Copyright and Related Rights include, but are not
 43 | limited to, the following:
 44 | 
 45 |   i. the right to reproduce, adapt, distribute, perform, display,
 46 |      communicate, and translate a Work;
 47 |  ii. moral rights retained by the original author(s) and/or performer(s);
 48 | iii. publicity and privacy rights pertaining to a person's image or
 49 |      likeness depicted in a Work;
 50 |  iv. rights protecting against unfair competition in regards to a Work,
 51 |      subject to the limitations in paragraph 4(a), below;
 52 |   v. rights protecting the extraction, dissemination, use and reuse of data
 53 |      in a Work;
 54 |  vi. database rights (such as those arising under Directive 96/9/EC of the
 55 |      European Parliament and of the Council of 11 March 1996 on the legal
 56 |      protection of databases, and under any national implementation
 57 |      thereof, including any amended or successor version of such
 58 |      directive); and
 59 | vii. other similar, equivalent or corresponding rights throughout the
 60 |      world based on applicable law or treaty, and any national
 61 |      implementations thereof.
 62 | 
 63 | 2. Waiver. To the greatest extent permitted by, but not in contravention
 64 | of, applicable law, Affirmer hereby overtly, fully, permanently,
 65 | irrevocably and unconditionally waives, abandons, and surrenders all of
 66 | Affirmer's Copyright and Related Rights and associated claims and causes
 67 | of action, whether now known or unknown (including existing as well as
 68 | future claims and causes of action), in the Work (i) in all territories
 69 | worldwide, (ii) for the maximum duration provided by applicable law or
 70 | treaty (including future time extensions), (iii) in any current or future
 71 | medium and for any number of copies, and (iv) for any purpose whatsoever,
 72 | including without limitation commercial, advertising or promotional
 73 | purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
 74 | member of the public at large and to the detriment of Affirmer's heirs and
 75 | successors, fully intending that such Waiver shall not be subject to
 76 | revocation, rescission, cancellation, termination, or any other legal or
 77 | equitable action to disrupt the quiet enjoyment of the Work by the public
 78 | as contemplated by Affirmer's express Statement of Purpose.
 79 | 
 80 | 3. Public License Fallback. Should any part of the Waiver for any reason
 81 | be judged legally invalid or ineffective under applicable law, then the
 82 | Waiver shall be preserved to the maximum extent permitted taking into
 83 | account Affirmer's express Statement of Purpose. In addition, to the
 84 | extent the Waiver is so judged Affirmer hereby grants to each affected
 85 | person a royalty-free, non transferable, non sublicensable, non exclusive,
 86 | irrevocable and unconditional license to exercise Affirmer's Copyright and
 87 | Related Rights in the Work (i) in all territories worldwide, (ii) for the
 88 | maximum duration provided by applicable law or treaty (including future
 89 | time extensions), (iii) in any current or future medium and for any number
 90 | of copies, and (iv) for any purpose whatsoever, including without
 91 | limitation commercial, advertising or promotional purposes (the
 92 | "License"). The License shall be deemed effective as of the date CC0 was
 93 | applied by Affirmer to the Work. Should any part of the License for any
 94 | reason be judged legally invalid or ineffective under applicable law, such
 95 | partial invalidity or ineffectiveness shall not invalidate the remainder
 96 | of the License, and in such case Affirmer hereby affirms that he or she
 97 | will not (i) exercise any of his or her remaining Copyright and Related
 98 | Rights in the Work or (ii) assert any associated claims and causes of
 99 | action with respect to the Work, in either case contrary to Affirmer's
100 | express Statement of Purpose.
101 | 
102 | 4. Limitations and Disclaimers.
103 | 
104 |  a. No trademark or patent rights held by Affirmer are waived, abandoned,
105 |     surrendered, licensed or otherwise affected by this document.
106 |  b. Affirmer offers the Work as-is and makes no representations or
107 |     warranties of any kind concerning the Work, express, implied,
108 |     statutory or otherwise, including without limitation warranties of
109 |     title, merchantability, fitness for a particular purpose, non
110 |     infringement, or the absence of latent or other defects, accuracy, or
111 |     the present or absence of errors, whether or not discoverable, all to
112 |     the greatest extent permissible under applicable law.
113 |  c. Affirmer disclaims responsibility for clearing rights of other persons
114 |     that may apply to the Work or any use thereof, including without
115 |     limitation any person's Copyright and Related Rights in the Work.
116 |     Further, Affirmer disclaims responsibility for obtaining any necessary
117 |     consents, permissions or other rights required for any use of the
118 |     Work.
119 |  d. Affirmer understands and acknowledges that Creative Commons is not a
120 |     party to this document and has no duty or obligation with respect to
121 |     this CC0 or use of the Work.
122 | 


--------------------------------------------------------------------------------