Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > sci.math > #514991 > unrolled thread

A cipher derived from a rational number.

Started bydjoyce099 <hlauk.h.bogart@gmail.com>
First post2021-03-20 14:22 -0700
Last post2021-03-25 00:15 +0000
Articles 20 on this page of 113 — 8 participants

Back to article view | Back to sci.math


Contents

  A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 14:22 -0700
    Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 14:24 -0700
    Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 14:25 -0700
      Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 14:33 -0700
        Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 14:39 -0700
          Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 15:18 -0700
            Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 15:23 -0700
              Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 15:34 -0700
                Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 15:42 -0700
                  Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 16:03 -0700
              Re: A cipher derived from a rational number. FromTheRafters <erratic@nomail.afraid.org> - 2021-03-20 19:04 -0400
            Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 15:36 -0700
              Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 15:46 -0700
                Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 16:09 -0700
                  Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 16:14 -0700
                    Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 16:18 -0700
                      Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 16:58 -0700
                        Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 17:05 -0700
                          Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 17:09 -0700
                            Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 17:14 -0700
                            Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 17:16 -0700
      Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 14:54 -0700
      Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 17:39 -0700
        Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 18:49 -0700
          Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 19:07 -0700
          Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 23:08 -0700
            Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-21 08:00 -0700
              Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-21 09:08 -0700
                Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-23 22:14 -0700
                  Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-24 12:43 -0700
                    Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-29 16:48 -0700
                      Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-30 11:36 -0700
                        Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-30 12:40 -0700
                          Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-30 14:29 -0700
                            Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-30 22:06 -0700
                          Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-30 15:42 -0700
                            Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-30 19:43 -0700
                              Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-31 15:09 -0700
                        Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-30 15:39 -0700
                          Re: A cipher derived from a rational number. James Waldby <j-waldby@no.no> - 2021-03-31 20:55 +0000
                            Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-31 15:08 -0700
                              Re: A cipher derived from a rational number. James Waldby <j-waldby@no.no> - 2021-03-31 23:24 +0000
                                Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-31 16:49 -0700
                                  Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-31 18:32 -0700
                                    Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-01 06:21 -0700
                                      Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-01 07:39 -0700
                                        Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-01 08:04 -0700
                                          Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-01 16:45 -0700
                                          Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-01 16:58 -0700
                                            Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-01 20:45 -0700
                                              Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-01 21:55 -0700
                                                Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-01 22:42 -0700
                                                  Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-02 07:23 -0700
                                                    Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-02 08:00 -0700
                                                      Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-02 08:42 -0700
                                                      Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-03 12:05 -0700
                                                  Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-02 15:01 -0700
                                                    Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-02 15:18 -0700
                                                      Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-02 15:32 -0700
                                                        Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-03 05:44 -0700
                                                          Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-03 11:59 -0700
                                                            Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-03 13:56 -0700
                                                              Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-03 14:09 -0700
                                                              Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-03 14:11 -0700
                                                                Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-03 16:50 -0700
                                                                  Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-03 17:09 -0700
                                                                    Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-03 20:08 -0700
                                                                      Re: A cipher derived from a rational number. FromTheRafters <erratic@nomail.afraid.org> - 2021-04-04 05:30 -0400
                                                                        Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-04 10:35 -0700
                                                                          Re: A cipher derived from a rational number. FromTheRafters <erratic@nomail.afraid.org> - 2021-04-04 14:10 -0400
                                                                            Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-04 13:29 -0700
                                                                              Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-05 06:27 -0700
                                                                                Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-05 08:15 -0700
                                                                        Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-04 14:28 -0700
                                                                          Re: A cipher derived from a rational number. FromTheRafters <erratic@nomail.afraid.org> - 2021-04-04 18:43 -0400
                                                                    Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-04 14:14 -0700
                                                                      Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-07 17:22 -0700
                                                                        Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-07 20:32 -0700
                                                                          Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-07 21:02 -0700
                                                                          Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-07 21:10 -0700
                                                                        Re: A cipher derived from a rational number. Lee Aecca <deea2@icc2ccne.jp> - 2021-04-08 10:43 +0000
                                                                          Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-08 15:13 -0700
                                                                            Re: A cipher derived from a rational number. FromTheRafters <erratic@nomail.afraid.org> - 2021-04-08 19:03 -0400
                                                                              Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-08 19:20 -0700
                                                                            Re: A cipher derived from a rational number. Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-04-09 02:51 +0100
                                                                              Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-08 19:18 -0700
                                                                                Re: A cipher derived from a rational number. FromTheRafters <erratic@nomail.afraid.org> - 2021-04-08 22:52 -0400
                                                                  Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-04 14:11 -0700
                                                                    Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-04-04 16:54 -0700
                            Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-31 15:13 -0700
                  Re: A cipher derived from a rational number. "mitchr...@gmail.com" <mitchrae3323@gmail.com> - 2021-03-24 13:21 -0700
                    Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-24 13:25 -0700
                  Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-25 14:07 -0700
                    Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-25 15:43 -0700
                      Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-25 15:51 -0700
                        Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-25 20:58 -0700
                      Re: A cipher derived from a rational number. FromTheRafters <erratic@nomail.afraid.org> - 2021-03-25 19:32 -0400
                        Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-25 17:50 -0700
                          Re: A cipher derived from a rational number. FromTheRafters <erratic@nomail.afraid.org> - 2021-03-26 05:09 -0400
                            Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-26 07:46 -0700
                              Re: A cipher derived from a rational number. FromTheRafters <erratic@nomail.afraid.org> - 2021-03-26 11:37 -0400
                              Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-28 19:02 -0700
                                Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-28 19:09 -0700
                    Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-25 20:47 -0700
                      Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-25 23:29 -0700
                        Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-25 23:41 -0700
    Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 14:27 -0700
    Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 14:43 -0700
    Re: A cipher derived from a rational number. "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-03-20 17:31 -0700
    Re: A cipher derived from a rational number. James Waldby <j-waldby@no.no> - 2021-03-21 03:06 +0000
    Re: A cipher derived from a rational number. James Waldby <j-waldby@no.no> - 2021-03-21 03:08 +0000
      Re: A cipher derived from a rational number. djoyce099 <hlauk.h.bogart@gmail.com> - 2021-03-20 20:33 -0700
      RE: Re: A cipher derived from a rational number. earle <earle.jones@comcast.net> - 2021-03-25 00:15 +0000

Page 3 of 6 — ← Prev page 1 2 [3] 4 5 6  Next page →


#516178

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-03-31 15:08 -0700
Message-ID<s42rse$a1e$1@gioia.aioe.org>
In reply to#516170
On 3/31/2021 1:55 PM, James Waldby wrote:
> Chris M. Thomasson <chris.m.thomasson.1@gmail.com> wrote:
>> On 3/30/2021 11:36 AM, djoyce099 wrote:
>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote:
>>>> On 3/24/2021 12:43 PM, djoyce099 wrote:
>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote:
> ...
>>>>>> Now wrt your work, can you decrypt this?
>>>>>>
>>>>>> 17.4016863080244085
>>>>>>
>>>>>> It uses my simple idea of multiplying against a constant in the secret
>>>>>> key. You should post it there.
> ...
>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are
>>>> different digits.
>>>>
>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the
>>>> convergents of the original rational and use your initial mapping of
>>>> numbers to letters to decrypt the message.
> ...
>> 2. followed by three digits. So, its not 2.877
> 
> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x
> < y < z, the only word I see is `gab`, from divider 2.269.

Its a number from 2.000 to 2.999. However, you need to divide 
17.4016863080244085 by it to get the original number that contains the 
plaintext in its convergents. The answer is below, spoiler alert:
















///






///

















































////



17.4016863080244085 / 2.123 = 8.1967434328895

8.1967434328895 has the convergents:

[8; 5 12 12 15]

The plaintext is: hello

;^)

[toc] | [prev] | [next] | [standalone]


#516190

FromJames Waldby <j-waldby@no.no>
Date2021-03-31 23:24 +0000
Message-ID<s430bs$d6q$1@dont-email.me>
In reply to#516178
Chris M. Thomasson <chris.m.thomasson.1@gmail.com> wrote:
> On 3/31/2021 1:55 PM, James Waldby wrote:
>> Chris M. Thomasson <chris.m.thomasson.1@gmail.com> wrote:
>>> On 3/30/2021 11:36 AM, djoyce099 wrote:
>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote:
>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote:
>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote:
>> ...
>>>>>>> Now wrt your work, can you decrypt this?
>>>>>>>
>>>>>>> 17.4016863080244085
>>>>>>>
>>>>>>> It uses my simple idea of multiplying against a constant in the secret
>>>>>>> key. You should post it there.
>> ...
>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are
>>>>> different digits.
>>>>>
>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the
>>>>> convergents of the original rational and use your initial mapping of
>>>>> numbers to letters to decrypt the message.
>> ...
>>> 2. followed by three digits. So, its not 2.877
>> 
>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x
>> < y < z, the only word I see is `gab`, from divider 2.269.
> 
> Its a number from 2.000 to 2.999. However, you need to divide 
> 17.4016863080244085 by it to get the original number that contains the 
> plaintext in its convergents. The answer is below, spoiler alert:
...
> 
> ////
> 
> 
> 
> 17.4016863080244085 / 2.123 = 8.1967434328895
> 
> 8.1967434328895 has the convergents:
> 
> [8; 5 12 12 15]
> 
> The plaintext is: hello
> 
> ;^)

Perhaps you didn't use arithmetic that was accurate enough?  The
convergents actually are [8; 5 12 12 14 1 282893 ...], which my
previously-mentioned continued-fractions-to-letters program showed as
`hellna`, which is not found in usual dictionaries.

On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...]

-jiw

[toc] | [prev] | [next] | [standalone]


#516191

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-03-31 16:49 -0700
Message-ID<s431pi$8if$1@gioia.aioe.org>
In reply to#516190
On 3/31/2021 4:24 PM, James Waldby wrote:
> Chris M. Thomasson <chris.m.thomasson.1@gmail.com> wrote:
>> On 3/31/2021 1:55 PM, James Waldby wrote:
>>> Chris M. Thomasson <chris.m.thomasson.1@gmail.com> wrote:
>>>> On 3/30/2021 11:36 AM, djoyce099 wrote:
>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote:
>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote:
>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote:
>>> ...
>>>>>>>> Now wrt your work, can you decrypt this?
>>>>>>>>
>>>>>>>> 17.4016863080244085
>>>>>>>>
>>>>>>>> It uses my simple idea of multiplying against a constant in the secret
>>>>>>>> key. You should post it there.
>>> ...
>>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are
>>>>>> different digits.
>>>>>>
>>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the
>>>>>> convergents of the original rational and use your initial mapping of
>>>>>> numbers to letters to decrypt the message.
>>> ...
>>>> 2. followed by three digits. So, its not 2.877
>>>
>>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x
>>> < y < z, the only word I see is `gab`, from divider 2.269.
>>
>> Its a number from 2.000 to 2.999. However, you need to divide
>> 17.4016863080244085 by it to get the original number that contains the
>> plaintext in its convergents. The answer is below, spoiler alert:
> ...
>>
>> ////
>>
>>
>>
>> 17.4016863080244085 / 2.123 = 8.1967434328895
>>
>> 8.1967434328895 has the convergents:
>>
>> [8; 5 12 12 15]
>>
>> The plaintext is: hello
>>
>> ;^)
> 
> Perhaps you didn't use arithmetic that was accurate enough?

Shit. Must have. The funny thing is that wolfram gives the convergents 
[8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or 
something.

https://www.wolframalpha.com/input/?i=8.1967434328895


>  The
> convergents actually are [8; 5 12 12 14 1 282893 ...], which my
> previously-mentioned continued-fractions-to-letters program showed as
> `hellna`, which is not found in usual dictionaries.
> 
> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...]

[toc] | [prev] | [next] | [standalone]


#516195

Fromdjoyce099 <hlauk.h.bogart@gmail.com>
Date2021-03-31 18:32 -0700
Message-ID<492aba22-a3b2-4d0a-8ee6-39730aae8e33n@googlegroups.com>
In reply to#516191
On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote:
> On 3/31/2021 4:24 PM, James Waldby wrote: 
> > Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> >> On 3/31/2021 1:55 PM, James Waldby wrote: 
> >>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> >>>> On 3/30/2021 11:36 AM, djoyce099 wrote: 
> >>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote: 
> >>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote: 
> >>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote: 
> >>> ... 
> >>>>>>>> Now wrt your work, can you decrypt this? 
> >>>>>>>> 
> >>>>>>>> 17.4016863080244085 
> >>>>>>>> 
> >>>>>>>> It uses my simple idea of multiplying against a constant in the secret 
> >>>>>>>> key. You should post it there. 
> >>> ... 
> >>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are 
> >>>>>> different digits. 
> >>>>>> 
> >>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the 
> >>>>>> convergents of the original rational and use your initial mapping of 
> >>>>>> numbers to letters to decrypt the message. 
> >>> ... 
> >>>> 2. followed by three digits. So, its not 2.877 
> >>> 
> >>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x 
> >>> < y < z, the only word I see is `gab`, from divider 2.269. 
> >> 
> >> Its a number from 2.000 to 2.999. However, you need to divide 
> >> 17.4016863080244085 by it to get the original number that contains the 
> >> plaintext in its convergents. The answer is below, spoiler alert: 
> > ... 
> >> 
> >> //// 
> >> 
> >> 
> >> 
> >> 17.4016863080244085 / 2.123 = 8.1967434328895 
> >> 
> >> 8.1967434328895 has the convergents: 
> >> 
> >> [8; 5 12 12 15] 
> >> 
> >> The plaintext is: hello 
> >> 
> >> ;^) 
> > 
> > Perhaps you didn't use arithmetic that was accurate enough?
> Shit. Must have. The funny thing is that wolfram gives the convergents 
> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or 
> something. 
> 
> https://www.wolframalpha.com/input/?i=8.1967434328895
> > The 
> > convergents actually are [8; 5 12 12 14 1 282893 ...], which my 
> > previously-mentioned continued-fractions-to-letters program showed as 
> > `hellna`, which is not found in usual dictionaries. 
> > 
> > On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...]

I am not sure how many digits in the decimal expansion of the target rational 
you need to compare to the number of terms in the cf.
I way overdid it in my first post but it was a longer message that was encrypted but 
probably could have used a much smaller in length rational to get the desired number of 
of terms in the cf for the number to letter conversion.

What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14..
and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13..
Think of it as using a slide rule where the private key
 (a string of random letters along with each group number identifiers) is on the fixed portion of the 
rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers.
These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter
with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted ---
A letter is only used once in the left to right scan like the word little the first T in little is used then the
scan continues by the decryptor for the second T because this private key string is made up of 49 alpha
characters = 26*2 minus the second XYZ = 49 Alpha characters and  1-7 group identifiers placed in the odd 
count positions. Example below where this is easy to decrypt by just this simple method --

----------------------------------------------------------------------------------------- Fixed  private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ"
 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7    >   Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving   --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan )
and scanning ----> again for the correct letter alignment to be cherry-picked from the private key.
This is giving the whole cipher idea away but the order of the characters in the private key can be drastically 
changed along with the group identifiers then the public key would be useless to the person without the new private string.
In a completed scan (end of too the right ------>), there could be several stops for letter alignments.
I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done. 
The above decryption of the public key above is easy if you follow the rules.     
This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s 
that worked great for encrypting and decrypting these numbers only 1-7 ciphers.
Just trying to transfer these thoughts into  Python but not getting anywhere yet.

[toc] | [prev] | [next] | [standalone]


#516228

Fromdjoyce099 <hlauk.h.bogart@gmail.com>
Date2021-04-01 06:21 -0700
Message-ID<f7edc95f-5c8b-4e02-82ab-f4606241c194n@googlegroups.com>
In reply to#516195
On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote:
> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote: 
> > On 3/31/2021 4:24 PM, James Waldby wrote: 
> > > Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> > >> On 3/31/2021 1:55 PM, James Waldby wrote: 
> > >>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> > >>>> On 3/30/2021 11:36 AM, djoyce099 wrote: 
> > >>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote: 
> > >>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote: 
> > >>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote: 
> > >>> ... 
> > >>>>>>>> Now wrt your work, can you decrypt this? 
> > >>>>>>>> 
> > >>>>>>>> 17.4016863080244085 
> > >>>>>>>> 
> > >>>>>>>> It uses my simple idea of multiplying against a constant in the secret 
> > >>>>>>>> key. You should post it there. 
> > >>> ... 
> > >>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are 
> > >>>>>> different digits. 
> > >>>>>> 
> > >>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the 
> > >>>>>> convergents of the original rational and use your initial mapping of 
> > >>>>>> numbers to letters to decrypt the message. 
> > >>> ... 
> > >>>> 2. followed by three digits. So, its not 2.877 
> > >>> 
> > >>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x 
> > >>> < y < z, the only word I see is `gab`, from divider 2.269. 
> > >> 
> > >> Its a number from 2.000 to 2.999. However, you need to divide 
> > >> 17.4016863080244085 by it to get the original number that contains the 
> > >> plaintext in its convergents. The answer is below, spoiler alert: 
> > > ... 
> > >> 
> > >> //// 
> > >> 
> > >> 
> > >> 
> > >> 17.4016863080244085 / 2.123 = 8.1967434328895 
> > >> 
> > >> 8.1967434328895 has the convergents: 
> > >> 
> > >> [8; 5 12 12 15] 
> > >> 
> > >> The plaintext is: hello 
> > >> 
> > >> ;^) 
> > > 
> > > Perhaps you didn't use arithmetic that was accurate enough? 
> > Shit. Must have. The funny thing is that wolfram gives the convergents 
> > [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or 
> > something. 
> > 
> > https://www.wolframalpha.com/input/?i=8.1967434328895 
> > > The 
> > > convergents actually are [8; 5 12 12 14 1 282893 ...], which my 
> > > previously-mentioned continued-fractions-to-letters program showed as 
> > > `hellna`, which is not found in usual dictionaries. 
> > > 
> > > On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...]
> I am not sure how many digits in the decimal expansion of the target rational 
> you need to compare to the number of terms in the cf. 
> I way overdid it in my first post but it was a longer message that was encrypted but 
> probably could have used a much smaller in length rational to get the desired number of 
> of terms in the cf for the number to letter conversion. 
> 
> What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14.. 
> and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13.. 
> Think of it as using a slide rule where the private key 
> (a string of random letters along with each group number identifiers) is on the fixed portion of the 
> rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers. 
> These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter 
> with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted --- 
> A letter is only used once in the left to right scan like the word little the first T in little is used then the 
> scan continues by the decryptor for the second T because this private key string is made up of 49 alpha 
> characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd 
> count positions. Example below where this is easy to decrypt by just this simple method -- 
> 
> ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ" 
> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan ) 
> and scanning ----> again for the correct letter alignment to be cherry-picked from the private key. 
> This is giving the whole cipher idea away but the order of the characters in the private key can be drastically 
> changed along with the group identifiers then the public key would be useless to the person without the new private string. 
> In a completed scan (end of too the right ------>), there could be several stops for letter alignments. 
> I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done. 
> The above decryption of the public key above is easy if you follow the rules. 
> This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s 
> that worked great for encrypting and decrypting these numbers only 1-7 ciphers. 
> Just trying to transfer these thoughts into Python but not getting anywhere yet.

Has anyone figured out, what I call, my seven square cipher yet?
Or found any flaws in the concept?  


[toc] | [prev] | [next] | [standalone]


#516235

Fromdjoyce099 <hlauk.h.bogart@gmail.com>
Date2021-04-01 07:39 -0700
Message-ID<539cf2dc-a733-4ed1-8739-dee2f30612dfn@googlegroups.com>
In reply to#516228
On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote:
> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote: 
> > On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote: 
> > > On 3/31/2021 4:24 PM, James Waldby wrote: 
> > > > Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> > > >> On 3/31/2021 1:55 PM, James Waldby wrote: 
> > > >>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> > > >>>> On 3/30/2021 11:36 AM, djoyce099 wrote: 
> > > >>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote: 
> > > >>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote: 
> > > >>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote: 
> > > >>> ... 
> > > >>>>>>>> Now wrt your work, can you decrypt this? 
> > > >>>>>>>> 
> > > >>>>>>>> 17.4016863080244085 
> > > >>>>>>>> 
> > > >>>>>>>> It uses my simple idea of multiplying against a constant in the secret 
> > > >>>>>>>> key. You should post it there. 
> > > >>> ... 
> > > >>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are 
> > > >>>>>> different digits. 
> > > >>>>>> 
> > > >>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the 
> > > >>>>>> convergents of the original rational and use your initial mapping of 
> > > >>>>>> numbers to letters to decrypt the message. 
> > > >>> ... 
> > > >>>> 2. followed by three digits. So, its not 2.877 
> > > >>> 
> > > >>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x 
> > > >>> < y < z, the only word I see is `gab`, from divider 2.269. 
> > > >> 
> > > >> Its a number from 2.000 to 2.999. However, you need to divide 
> > > >> 17.4016863080244085 by it to get the original number that contains the 
> > > >> plaintext in its convergents. The answer is below, spoiler alert: 
> > > > ... 
> > > >> 
> > > >> //// 
> > > >> 
> > > >> 
> > > >> 
> > > >> 17.4016863080244085 / 2.123 = 8.1967434328895 
> > > >> 
> > > >> 8.1967434328895 has the convergents: 
> > > >> 
> > > >> [8; 5 12 12 15] 
> > > >> 
> > > >> The plaintext is: hello 
> > > >> 
> > > >> ;^) 
> > > > 
> > > > Perhaps you didn't use arithmetic that was accurate enough? 
> > > Shit. Must have. The funny thing is that wolfram gives the convergents 
> > > [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or 
> > > something. 
> > > 
> > > https://www.wolframalpha.com/input/?i=8.1967434328895 
> > > > The 
> > > > convergents actually are [8; 5 12 12 14 1 282893 ...], which my 
> > > > previously-mentioned continued-fractions-to-letters program showed as 
> > > > `hellna`, which is not found in usual dictionaries. 
> > > > 
> > > > On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...] 
> > I am not sure how many digits in the decimal expansion of the target rational 
> > you need to compare to the number of terms in the cf. 
> > I way overdid it in my first post but it was a longer message that was encrypted but 
> > probably could have used a much smaller in length rational to get the desired number of 
> > of terms in the cf for the number to letter conversion. 
> > 
> > What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14.. 
> > and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13.. 
> > Think of it as using a slide rule where the private key 
> > (a string of random letters along with each group number identifiers) is on the fixed portion of the 
> > rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers. 
> > These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter 
> > with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted --- 
> > A letter is only used once in the left to right scan like the word little the first T in little is used then the 
> > scan continues by the decryptor for the second T because this private key string is made up of 49 alpha 
> > characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd 
> > count positions. Example below where this is easy to decrypt by just this simple method -- 
> > 
> > ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ" 
> > 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan ) 
> > and scanning ----> again for the correct letter alignment to be cherry-picked from the private key. 
> > This is giving the whole cipher idea away but the order of the characters in the private key can be drastically 
> > changed along with the group identifiers then the public key would be useless to the person without the new private string. 
> > In a completed scan (end of too the right ------>), there could be several stops for letter alignments. 
> > I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done. 
> > The above decryption of the public key above is easy if you follow the rules. 
> > This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s 
> > that worked great for encrypting and decrypting these numbers only 1-7 ciphers. 
> > Just trying to transfer these thoughts into Python but not getting anywhere yet.
> Has anyone figured out, what I call, my seven square cipher yet? 
> Or found any flaws in the concept?

Adding a level of security to any public key cipher of the above nature the group identifiers could be changed 
to a different identifier position after each message sent.
This way no patterns of odd position numbers can be detected even though some
identifiers sometimes are used in succession breaking any pattern possible with future cipher messages.

You may ask, why did I reveal the secrets to this cipher?
Okay, Just say I presented the public key ---
5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7
Then said, solve this cipher, what is the hidden written message these numbers represent?
 Duh, This is more powerful than even the German enigma machine.
This is because the public key encoded numeric message can be any length but the
 private key is just 56 characters long. 1-7 group identifiers randomly located and the 49 Alpha characters. 
In other words, I would die with this secret. ;-)  

[toc] | [prev] | [next] | [standalone]


#516243

Fromdjoyce099 <hlauk.h.bogart@gmail.com>
Date2021-04-01 08:04 -0700
Message-ID<89806012-185d-46e9-9ff1-f37b1a2ff2den@googlegroups.com>
In reply to#516235
On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote:
> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote: 
> > On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote: 
> > > On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote: 
> > > > On 3/31/2021 4:24 PM, James Waldby wrote: 
> > > > > Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> > > > >> On 3/31/2021 1:55 PM, James Waldby wrote: 
> > > > >>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> > > > >>>> On 3/30/2021 11:36 AM, djoyce099 wrote: 
> > > > >>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote: 
> > > > >>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote: 
> > > > >>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote: 
> > > > >>> ... 
> > > > >>>>>>>> Now wrt your work, can you decrypt this? 
> > > > >>>>>>>> 
> > > > >>>>>>>> 17.4016863080244085 
> > > > >>>>>>>> 
> > > > >>>>>>>> It uses my simple idea of multiplying against a constant in the secret 
> > > > >>>>>>>> key. You should post it there. 
> > > > >>> ... 
> > > > >>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are 
> > > > >>>>>> different digits. 
> > > > >>>>>> 
> > > > >>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the 
> > > > >>>>>> convergents of the original rational and use your initial mapping of 
> > > > >>>>>> numbers to letters to decrypt the message. 
> > > > >>> ... 
> > > > >>>> 2. followed by three digits. So, its not 2.877 
> > > > >>> 
> > > > >>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x 
> > > > >>> < y < z, the only word I see is `gab`, from divider 2.269. 
> > > > >> 
> > > > >> Its a number from 2.000 to 2.999. However, you need to divide 
> > > > >> 17.4016863080244085 by it to get the original number that contains the 
> > > > >> plaintext in its convergents. The answer is below, spoiler alert: 
> > > > > ... 
> > > > >> 
> > > > >> //// 
> > > > >> 
> > > > >> 
> > > > >> 
> > > > >> 17.4016863080244085 / 2.123 = 8.1967434328895 
> > > > >> 
> > > > >> 8.1967434328895 has the convergents: 
> > > > >> 
> > > > >> [8; 5 12 12 15] 
> > > > >> 
> > > > >> The plaintext is: hello 
> > > > >> 
> > > > >> ;^) 
> > > > > 
> > > > > Perhaps you didn't use arithmetic that was accurate enough? 
> > > > Shit. Must have. The funny thing is that wolfram gives the convergents 
> > > > [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or 
> > > > something. 
> > > > 
> > > > https://www.wolframalpha.com/input/?i=8.1967434328895 
> > > > > The 
> > > > > convergents actually are [8; 5 12 12 14 1 282893 ...], which my 
> > > > > previously-mentioned continued-fractions-to-letters program showed as 
> > > > > `hellna`, which is not found in usual dictionaries. 
> > > > > 
> > > > > On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...] 
> > > I am not sure how many digits in the decimal expansion of the target rational 
> > > you need to compare to the number of terms in the cf. 
> > > I way overdid it in my first post but it was a longer message that was encrypted but 
> > > probably could have used a much smaller in length rational to get the desired number of 
> > > of terms in the cf for the number to letter conversion. 
> > > 
> > > What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14.. 
> > > and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13.. 
> > > Think of it as using a slide rule where the private key 
> > > (a string of random letters along with each group number identifiers) is on the fixed portion of the 
> > > rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers. 
> > > These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter 
> > > with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted --- 
> > > A letter is only used once in the left to right scan like the word little the first T in little is used then the 
> > > scan continues by the decryptor for the second T because this private key string is made up of 49 alpha 
> > > characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd 
> > > count positions. Example below where this is easy to decrypt by just this simple method -- 
> > > 
> > > ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ" 
> > > 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan ) 
> > > and scanning ----> again for the correct letter alignment to be cherry-picked from the private key. 
> > > This is giving the whole cipher idea away but the order of the characters in the private key can be drastically 
> > > changed along with the group identifiers then the public key would be useless to the person without the new private string. 
> > > In a completed scan (end of too the right ------>), there could be several stops for letter alignments. 
> > > I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done. 
> > > The above decryption of the public key above is easy if you follow the rules. 
> > > This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s 
> > > that worked great for encrypting and decrypting these numbers only 1-7 ciphers. 
> > > Just trying to transfer these thoughts into Python but not getting anywhere yet. 
> > Has anyone figured out, what I call, my seven square cipher yet? 
> > Or found any flaws in the concept?
> Adding a level of security to any public key cipher of the above nature the group identifiers could be changed 
> to a different identifier position after each message sent. 
> This way no patterns of odd position numbers can be detected even though some 
> identifiers sometimes are used in succession breaking any pattern possible with future cipher messages. 
> 
> You may ask, why did I reveal the secrets to this cipher? 
> Okay, Just say I presented the public key --- 
> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 
> Then said, solve this cipher, what is the hidden written message these numbers represent? 
> Duh, This is more powerful than even the German enigma machine. 
> This is because the public key encoded numeric message can be any length but the 
> private key is just 56 characters long. 1-7 group identifiers randomly located and the 49 Alpha characters. 
> In other words, I would die with this secret. ;-)

That was stupid of me, The above cipher can be solved by anyone knowing the rules and the private
key already revealed.

[toc] | [prev] | [next] | [standalone]


#516280

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-01 16:45 -0700
Message-ID<s45lv3$8fq$2@gioia.aioe.org>
In reply to#516243
On 4/1/2021 8:04 AM, djoyce099 wrote:
> On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote:
>> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote:
>>> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote:
>>>> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote:
>>>>> On 3/31/2021 4:24 PM, James Waldby wrote:
>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>>>> On 3/31/2021 1:55 PM, James Waldby wrote:
>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>>>>>> On 3/30/2021 11:36 AM, djoyce099 wrote:
>>>>>>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote:
>>>>>>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote:
>>>>>>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote:
>>>>>>>> ...
>>>>>>>>>>>>> Now wrt your work, can you decrypt this?
>>>>>>>>>>>>>
>>>>>>>>>>>>> 17.4016863080244085
>>>>>>>>>>>>>
>>>>>>>>>>>>> It uses my simple idea of multiplying against a constant in the secret
>>>>>>>>>>>>> key. You should post it there.
>>>>>>>> ...
>>>>>>>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are
>>>>>>>>>>> different digits.
>>>>>>>>>>>
>>>>>>>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the
>>>>>>>>>>> convergents of the original rational and use your initial mapping of
>>>>>>>>>>> numbers to letters to decrypt the message.
>>>>>>>> ...
>>>>>>>>> 2. followed by three digits. So, its not 2.877
>>>>>>>>
>>>>>>>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x
>>>>>>>> < y < z, the only word I see is `gab`, from divider 2.269.
>>>>>>>
>>>>>>> Its a number from 2.000 to 2.999. However, you need to divide
>>>>>>> 17.4016863080244085 by it to get the original number that contains the
>>>>>>> plaintext in its convergents. The answer is below, spoiler alert:
>>>>>> ...
>>>>>>>
>>>>>>> ////
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> 17.4016863080244085 / 2.123 = 8.1967434328895
>>>>>>>
>>>>>>> 8.1967434328895 has the convergents:
>>>>>>>
>>>>>>> [8; 5 12 12 15]
>>>>>>>
>>>>>>> The plaintext is: hello
>>>>>>>
>>>>>>> ;^)
>>>>>>
>>>>>> Perhaps you didn't use arithmetic that was accurate enough?
>>>>> Shit. Must have. The funny thing is that wolfram gives the convergents
>>>>> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or
>>>>> something.
>>>>>
>>>>> https://www.wolframalpha.com/input/?i=8.1967434328895
>>>>>> The
>>>>>> convergents actually are [8; 5 12 12 14 1 282893 ...], which my
>>>>>> previously-mentioned continued-fractions-to-letters program showed as
>>>>>> `hellna`, which is not found in usual dictionaries.
>>>>>>
>>>>>> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...]
>>>> I am not sure how many digits in the decimal expansion of the target rational
>>>> you need to compare to the number of terms in the cf.
>>>> I way overdid it in my first post but it was a longer message that was encrypted but
>>>> probably could have used a much smaller in length rational to get the desired number of
>>>> of terms in the cf for the number to letter conversion.
>>>>
>>>> What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14..
>>>> and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13..
>>>> Think of it as using a slide rule where the private key
>>>> (a string of random letters along with each group number identifiers) is on the fixed portion of the
>>>> rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers.
>>>> These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter
>>>> with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted ---
>>>> A letter is only used once in the left to right scan like the word little the first T in little is used then the
>>>> scan continues by the decryptor for the second T because this private key string is made up of 49 alpha
>>>> characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd
>>>> count positions. Example below where this is easy to decrypt by just this simple method --
>>>>
>>>> ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ"
>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan )
>>>> and scanning ----> again for the correct letter alignment to be cherry-picked from the private key.
>>>> This is giving the whole cipher idea away but the order of the characters in the private key can be drastically
>>>> changed along with the group identifiers then the public key would be useless to the person without the new private string.
>>>> In a completed scan (end of too the right ------>), there could be several stops for letter alignments.
>>>> I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done.
>>>> The above decryption of the public key above is easy if you follow the rules.
>>>> This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s
>>>> that worked great for encrypting and decrypting these numbers only 1-7 ciphers.
>>>> Just trying to transfer these thoughts into Python but not getting anywhere yet.
>>> Has anyone figured out, what I call, my seven square cipher yet?
>>> Or found any flaws in the concept?
>> Adding a level of security to any public key cipher of the above nature the group identifiers could be changed
>> to a different identifier position after each message sent.
>> This way no patterns of odd position numbers can be detected even though some
>> identifiers sometimes are used in succession breaking any pattern possible with future cipher messages.
>>
>> You may ask, why did I reveal the secrets to this cipher?
>> Okay, Just say I presented the public key ---
>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7
>> Then said, solve this cipher, what is the hidden written message these numbers represent?
>> Duh, This is more powerful than even the German enigma machine.
>> This is because the public key encoded numeric message can be any length but the
>> private key is just 56 characters long. 1-7 group identifiers randomly located and the 49 Alpha characters.
>> In other words, I would die with this secret. ;-)
> 
> That was stupid of me, The above cipher can be solved by anyone knowing the rules and the private
> key already revealed.
> 

I am working on other things right now, but you really should post this 
over in sci.crypt. You need to think of a lot of different types of 
attacks. One of them is a known plaintext attack.

[toc] | [prev] | [next] | [standalone]


#516284

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-01 16:58 -0700
Message-ID<s45mmp$hk0$1@gioia.aioe.org>
In reply to#516243
On 4/1/2021 8:04 AM, djoyce099 wrote:
> On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote:
>> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote:
>>> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote:
>>>> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote:
>>>>> On 3/31/2021 4:24 PM, James Waldby wrote:
>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>>>> On 3/31/2021 1:55 PM, James Waldby wrote:
>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>>>>>> On 3/30/2021 11:36 AM, djoyce099 wrote:
>>>>>>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote:
>>>>>>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote:
>>>>>>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote:
>>>>>>>> ...
>>>>>>>>>>>>> Now wrt your work, can you decrypt this?
>>>>>>>>>>>>>
>>>>>>>>>>>>> 17.4016863080244085
>>>>>>>>>>>>>
>>>>>>>>>>>>> It uses my simple idea of multiplying against a constant in the secret
>>>>>>>>>>>>> key. You should post it there.
>>>>>>>> ...
>>>>>>>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are
>>>>>>>>>>> different digits.
>>>>>>>>>>>
>>>>>>>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the
>>>>>>>>>>> convergents of the original rational and use your initial mapping of
>>>>>>>>>>> numbers to letters to decrypt the message.
>>>>>>>> ...
>>>>>>>>> 2. followed by three digits. So, its not 2.877
>>>>>>>>
>>>>>>>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x
>>>>>>>> < y < z, the only word I see is `gab`, from divider 2.269.
>>>>>>>
>>>>>>> Its a number from 2.000 to 2.999. However, you need to divide
>>>>>>> 17.4016863080244085 by it to get the original number that contains the
>>>>>>> plaintext in its convergents. The answer is below, spoiler alert:
>>>>>> ...
>>>>>>>
>>>>>>> ////
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> 17.4016863080244085 / 2.123 = 8.1967434328895
>>>>>>>
>>>>>>> 8.1967434328895 has the convergents:
>>>>>>>
>>>>>>> [8; 5 12 12 15]
>>>>>>>
>>>>>>> The plaintext is: hello
>>>>>>>
>>>>>>> ;^)
>>>>>>
>>>>>> Perhaps you didn't use arithmetic that was accurate enough?
>>>>> Shit. Must have. The funny thing is that wolfram gives the convergents
>>>>> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or
>>>>> something.
>>>>>
>>>>> https://www.wolframalpha.com/input/?i=8.1967434328895
>>>>>> The
>>>>>> convergents actually are [8; 5 12 12 14 1 282893 ...], which my
>>>>>> previously-mentioned continued-fractions-to-letters program showed as
>>>>>> `hellna`, which is not found in usual dictionaries.
>>>>>>
>>>>>> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...]
>>>> I am not sure how many digits in the decimal expansion of the target rational
>>>> you need to compare to the number of terms in the cf.
>>>> I way overdid it in my first post but it was a longer message that was encrypted but
>>>> probably could have used a much smaller in length rational to get the desired number of
>>>> of terms in the cf for the number to letter conversion.
>>>>
>>>> What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14..
>>>> and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13..
>>>> Think of it as using a slide rule where the private key
>>>> (a string of random letters along with each group number identifiers) is on the fixed portion of the
>>>> rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers.
>>>> These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter
>>>> with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted ---
>>>> A letter is only used once in the left to right scan like the word little the first T in little is used then the
>>>> scan continues by the decryptor for the second T because this private key string is made up of 49 alpha
>>>> characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd
>>>> count positions. Example below where this is easy to decrypt by just this simple method --
>>>>
>>>> ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ"
>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan )
>>>> and scanning ----> again for the correct letter alignment to be cherry-picked from the private key.
>>>> This is giving the whole cipher idea away but the order of the characters in the private key can be drastically
>>>> changed along with the group identifiers then the public key would be useless to the person without the new private string.
>>>> In a completed scan (end of too the right ------>), there could be several stops for letter alignments.
>>>> I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done.
>>>> The above decryption of the public key above is easy if you follow the rules.
>>>> This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s
>>>> that worked great for encrypting and decrypting these numbers only 1-7 ciphers.
>>>> Just trying to transfer these thoughts into Python but not getting anywhere yet.
>>> Has anyone figured out, what I call, my seven square cipher yet?
>>> Or found any flaws in the concept?
>> Adding a level of security to any public key cipher of the above nature the group identifiers could be changed
>> to a different identifier position after each message sent.
>> This way no patterns of odd position numbers can be detected even though some
>> identifiers sometimes are used in succession breaking any pattern possible with future cipher messages.
>>
>> You may ask, why did I reveal the secrets to this cipher?
>> Okay, Just say I presented the public key ---
>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7
>> Then said, solve this cipher, what is the hidden written message these numbers represent?
>> Duh, This is more powerful than even the German enigma machine.
>> This is because the public key encoded numeric message can be any length but the
>> private key is just 56 characters long. 1-7 group identifiers randomly located and the 49 Alpha characters.
>> In other words, I would die with this secret. ;-)
> 
> That was stupid of me, The above cipher can be solved by anyone knowing the rules and the private
> key already revealed.
> 

Also, if you are going to develop a cipher out of this, you need to make 
sure that every encryption generates a radically different ciphertext, 
even for the exact same plaintext. So encrypting the same plaintext 
several times in a row would produce very different ciphertexts.

[toc] | [prev] | [next] | [standalone]


#516312

Fromdjoyce099 <hlauk.h.bogart@gmail.com>
Date2021-04-01 20:45 -0700
Message-ID<5982de33-38b8-4ebb-9f63-d7e6443172bbn@googlegroups.com>
In reply to#516284
On Thursday, April 1, 2021 at 7:58:28 PM UTC-4, Chris M. Thomasson wrote:
> On 4/1/2021 8:04 AM, djoyce099 wrote: 
> > On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote: 
> >> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote: 
> >>> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote: 
> >>>> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote: 
> >>>>> On 3/31/2021 4:24 PM, James Waldby wrote: 
> >>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> >>>>>>> On 3/31/2021 1:55 PM, James Waldby wrote: 
> >>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> >>>>>>>>> On 3/30/2021 11:36 AM, djoyce099 wrote: 
> >>>>>>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote: 
> >>>>>>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote: 
> >>>>>>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote: 
> >>>>>>>> ... 
> >>>>>>>>>>>>> Now wrt your work, can you decrypt this? 
> >>>>>>>>>>>>> 
> >>>>>>>>>>>>> 17.4016863080244085 
> >>>>>>>>>>>>> 
> >>>>>>>>>>>>> It uses my simple idea of multiplying against a constant in the secret 
> >>>>>>>>>>>>> key. You should post it there. 
> >>>>>>>> ... 
> >>>>>>>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are 
> >>>>>>>>>>> different digits. 
> >>>>>>>>>>> 
> >>>>>>>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the 
> >>>>>>>>>>> convergents of the original rational and use your initial mapping of 
> >>>>>>>>>>> numbers to letters to decrypt the message. 
> >>>>>>>> ... 
> >>>>>>>>> 2. followed by three digits. So, its not 2.877 
> >>>>>>>> 
> >>>>>>>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x 
> >>>>>>>> < y < z, the only word I see is `gab`, from divider 2.269. 
> >>>>>>> 
> >>>>>>> Its a number from 2.000 to 2.999. However, you need to divide 
> >>>>>>> 17.4016863080244085 by it to get the original number that contains the 
> >>>>>>> plaintext in its convergents. The answer is below, spoiler alert: 
> >>>>>> ... 
> >>>>>>> 
> >>>>>>> //// 
> >>>>>>> 
> >>>>>>> 
> >>>>>>> 
> >>>>>>> 17.4016863080244085 / 2.123 = 8.1967434328895 
> >>>>>>> 
> >>>>>>> 8.1967434328895 has the convergents: 
> >>>>>>> 
> >>>>>>> [8; 5 12 12 15] 
> >>>>>>> 
> >>>>>>> The plaintext is: hello 
> >>>>>>> 
> >>>>>>> ;^) 
> >>>>>> 
> >>>>>> Perhaps you didn't use arithmetic that was accurate enough? 
> >>>>> Shit. Must have. The funny thing is that wolfram gives the convergents 
> >>>>> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or 
> >>>>> something. 
> >>>>> 
> >>>>> https://www.wolframalpha.com/input/?i=8.1967434328895 
> >>>>>> The 
> >>>>>> convergents actually are [8; 5 12 12 14 1 282893 ...], which my 
> >>>>>> previously-mentioned continued-fractions-to-letters program showed as 
> >>>>>> `hellna`, which is not found in usual dictionaries. 
> >>>>>> 
> >>>>>> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...] 
> >>>> I am not sure how many digits in the decimal expansion of the target rational 
> >>>> you need to compare to the number of terms in the cf. 
> >>>> I way overdid it in my first post but it was a longer message that was encrypted but 
> >>>> probably could have used a much smaller in length rational to get the desired number of 
> >>>> of terms in the cf for the number to letter conversion. 
> >>>> 
> >>>> What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14.. 
> >>>> and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13.. 
> >>>> Think of it as using a slide rule where the private key 
> >>>> (a string of random letters along with each group number identifiers) is on the fixed portion of the 
> >>>> rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers. 
> >>>> These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter 
> >>>> with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted --- 
> >>>> A letter is only used once in the left to right scan like the word little the first T in little is used then the 
> >>>> scan continues by the decryptor for the second T because this private key string is made up of 49 alpha 
> >>>> characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd 
> >>>> count positions. Example below where this is easy to decrypt by just this simple method -- 
> >>>> 
> >>>> ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ" 
> >>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan ) 
> >>>> and scanning ----> again for the correct letter alignment to be cherry-picked from the private key. 
> >>>> This is giving the whole cipher idea away but the order of the characters in the private key can be drastically 
> >>>> changed along with the group identifiers then the public key would be useless to the person without the new private string. 
> >>>> In a completed scan (end of too the right ------>), there could be several stops for letter alignments. 
> >>>> I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done. 
> >>>> The above decryption of the public key above is easy if you follow the rules. 
> >>>> This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s 
> >>>> that worked great for encrypting and decrypting these numbers only 1-7 ciphers. 
> >>>> Just trying to transfer these thoughts into Python but not getting anywhere yet. 
> >>> Has anyone figured out, what I call, my seven square cipher yet? 
> >>> Or found any flaws in the concept? 
> >> Adding a level of security to any public key cipher of the above nature the group identifiers could be changed 
> >> to a different identifier position after each message sent. 
> >> This way no patterns of odd position numbers can be detected even though some 
> >> identifiers sometimes are used in succession breaking any pattern possible with future cipher messages. 
> >> 
> >> You may ask, why did I reveal the secrets to this cipher? 
> >> Okay, Just say I presented the public key --- 
> >> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 
> >> Then said, solve this cipher, what is the hidden written message these numbers represent? 
> >> Duh, This is more powerful than even the German enigma machine. 
> >> This is because the public key encoded numeric message can be any length but the 
> >> private key is just 56 characters long. 1-7 group identifiers randomly located and the 49 Alpha characters. 
> >> In other words, I would die with this secret. ;-) 
> > 
> > That was stupid of me, The above cipher can be solved by anyone knowing the rules and the private 
> > key already revealed. 
> >
> Also, if you are going to develop a cipher out of this, you need to make 
> sure that every encryption generates a radically different ciphertext, 
> even for the exact same plaintext. So encrypting the same plaintext 
> several times in a row would produce very different ciphertexts.

Yes this is true, but because only 7 digits are used to pick an alpha character of 26 possibilities
only the order of these 7 group identifiers is changed after each message
The different combinations are 7! . A lot of messages (5048). Changed randomly.  This way no letter connections
other than a few out of 7 letters in a  few groups after a few messages are sent but then complete contradictory results 
pointing to a letter involved with one particular identifier group of 7 letters.
A bunch of test ciphertext would have to be processed to prove this point. 
The order right now of these group identifiers in this one example of the private key above is  ---  3,5,1,6,2,7,4 and in
odd positions in the private key alpha string ---  1,9,17,25,33,41,49 whose position never changes.
3,5,1,6,2,7,4 have 7! unique possibilities or (5040 possibilities) chosen from a random table of these possibilities.
So only a 7 number change is necessary and once in a while change the random order (predetermined in a certain
order of vowels and consonance strategically located in all the private string (groups of 7) should do the trick.. 
Did you solve the cipher yet?
 I gave plenty of info by using the slide rule method and the actual private key and ciphertext associated with it. 

[toc] | [prev] | [next] | [standalone]


#516324

Fromdjoyce099 <hlauk.h.bogart@gmail.com>
Date2021-04-01 21:55 -0700
Message-ID<149c5797-e4a0-4afe-beff-f3001da5f4a0n@googlegroups.com>
In reply to#516312
On Thursday, April 1, 2021 at 11:45:36 PM UTC-4, djoyce099 wrote:
> On Thursday, April 1, 2021 at 7:58:28 PM UTC-4, Chris M. Thomasson wrote: 
> > On 4/1/2021 8:04 AM, djoyce099 wrote: 
> > > On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote: 
> > >> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote: 
> > >>> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote: 
> > >>>> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote: 
> > >>>>> On 3/31/2021 4:24 PM, James Waldby wrote: 
> > >>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> > >>>>>>> On 3/31/2021 1:55 PM, James Waldby wrote: 
> > >>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> > >>>>>>>>> On 3/30/2021 11:36 AM, djoyce099 wrote: 
> > >>>>>>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote: 
> > >>>>>>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote: 
> > >>>>>>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote: 
> > >>>>>>>> ... 
> > >>>>>>>>>>>>> Now wrt your work, can you decrypt this? 
> > >>>>>>>>>>>>> 
> > >>>>>>>>>>>>> 17.4016863080244085 
> > >>>>>>>>>>>>> 
> > >>>>>>>>>>>>> It uses my simple idea of multiplying against a constant in the secret 
> > >>>>>>>>>>>>> key. You should post it there. 
> > >>>>>>>> ... 
> > >>>>>>>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are 
> > >>>>>>>>>>> different digits. 
> > >>>>>>>>>>> 
> > >>>>>>>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the 
> > >>>>>>>>>>> convergents of the original rational and use your initial mapping of 
> > >>>>>>>>>>> numbers to letters to decrypt the message. 
> > >>>>>>>> ... 
> > >>>>>>>>> 2. followed by three digits. So, its not 2.877 
> > >>>>>>>> 
> > >>>>>>>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x 
> > >>>>>>>> < y < z, the only word I see is `gab`, from divider 2.269. 
> > >>>>>>> 
> > >>>>>>> Its a number from 2.000 to 2.999. However, you need to divide 
> > >>>>>>> 17.4016863080244085 by it to get the original number that contains the 
> > >>>>>>> plaintext in its convergents. The answer is below, spoiler alert: 
> > >>>>>> ... 
> > >>>>>>> 
> > >>>>>>> //// 
> > >>>>>>> 
> > >>>>>>> 
> > >>>>>>> 
> > >>>>>>> 17.4016863080244085 / 2.123 = 8.1967434328895 
> > >>>>>>> 
> > >>>>>>> 8.1967434328895 has the convergents: 
> > >>>>>>> 
> > >>>>>>> [8; 5 12 12 15] 
> > >>>>>>> 
> > >>>>>>> The plaintext is: hello 
> > >>>>>>> 
> > >>>>>>> ;^) 
> > >>>>>> 
> > >>>>>> Perhaps you didn't use arithmetic that was accurate enough? 
> > >>>>> Shit. Must have. The funny thing is that wolfram gives the convergents 
> > >>>>> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or 
> > >>>>> something. 
> > >>>>> 
> > >>>>> https://www.wolframalpha.com/input/?i=8.1967434328895 
> > >>>>>> The 
> > >>>>>> convergents actually are [8; 5 12 12 14 1 282893 ...], which my 
> > >>>>>> previously-mentioned continued-fractions-to-letters program showed as 
> > >>>>>> `hellna`, which is not found in usual dictionaries. 
> > >>>>>> 
> > >>>>>> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...] 
> > >>>> I am not sure how many digits in the decimal expansion of the target rational 
> > >>>> you need to compare to the number of terms in the cf. 
> > >>>> I way overdid it in my first post but it was a longer message that was encrypted but 
> > >>>> probably could have used a much smaller in length rational to get the desired number of 
> > >>>> of terms in the cf for the number to letter conversion. 
> > >>>> 
> > >>>> What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14.. 
> > >>>> and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13.. 
> > >>>> Think of it as using a slide rule where the private key 
> > >>>> (a string of random letters along with each group number identifiers) is on the fixed portion of the 
> > >>>> rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers. 
> > >>>> These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter 
> > >>>> with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted --- 
> > >>>> A letter is only used once in the left to right scan like the word little the first T in little is used then the 
> > >>>> scan continues by the decryptor for the second T because this private key string is made up of 49 alpha 
> > >>>> characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd 
> > >>>> count positions. Example below where this is easy to decrypt by just this simple method -- 
> > >>>> 
> > >>>> ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ" 
> > >>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan ) 
> > >>>> and scanning ----> again for the correct letter alignment to be cherry-picked from the private key. 
> > >>>> This is giving the whole cipher idea away but the order of the characters in the private key can be drastically 
> > >>>> changed along with the group identifiers then the public key would be useless to the person without the new private string. 
> > >>>> In a completed scan (end of too the right ------>), there could be several stops for letter alignments. 
> > >>>> I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done. 
> > >>>> The above decryption of the public key above is easy if you follow the rules. 
> > >>>> This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s 
> > >>>> that worked great for encrypting and decrypting these numbers only 1-7 ciphers. 
> > >>>> Just trying to transfer these thoughts into Python but not getting anywhere yet. 
> > >>> Has anyone figured out, what I call, my seven square cipher yet? 
> > >>> Or found any flaws in the concept? 
> > >> Adding a level of security to any public key cipher of the above nature the group identifiers could be changed 
> > >> to a different identifier position after each message sent. 
> > >> This way no patterns of odd position numbers can be detected even though some 
> > >> identifiers sometimes are used in succession breaking any pattern possible with future cipher messages. 
> > >> 
> > >> You may ask, why did I reveal the secrets to this cipher? 
> > >> Okay, Just say I presented the public key --- 
> > >> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 
> > >> Then said, solve this cipher, what is the hidden written message these numbers represent? 
> > >> Duh, This is more powerful than even the German enigma machine. 
> > >> This is because the public key encoded numeric message can be any length but the 
> > >> private key is just 56 characters long. 1-7 group identifiers randomly located and the 49 Alpha characters. 
> > >> In other words, I would die with this secret. ;-) 
> > > 
> > > That was stupid of me, The above cipher can be solved by anyone knowing the rules and the private 
> > > key already revealed. 
> > > 
> > Also, if you are going to develop a cipher out of this, you need to make 
> > sure that every encryption generates a radically different ciphertext, 
> > even for the exact same plaintext. So encrypting the same plaintext 
> > several times in a row would produce very different ciphertexts.
> Yes this is true, but because only 7 digits are used to pick an alpha character of 26 possibilities 
> only the order of these 7 group identifiers is changed after each message 
> The different combinations are 7! . A lot of messages (5048). Changed randomly. This way no letter connections 
> other than a few out of 7 letters in a few groups after a few messages are sent but then complete contradictory results 
> pointing to a letter involved with one particular identifier group of 7 letters. 
> A bunch of test ciphertext would have to be processed to prove this point. 
> The order right now of these group identifiers in this one example of the private key above is --- 3,5,1,6,2,7,4 and in 
> odd positions in the private key alpha string --- 1,9,17,25,33,41,49 whose position never changes. 
> 3,5,1,6,2,7,4 have 7! unique possibilities or (5040 possibilities) chosen from a random table of these possibilities. 
> So only a 7 number change is necessary and once in a while change the random order (predetermined in a certain 
> order of vowels and consonance strategically located in all the private string (groups of 7) should do the trick.. 
> Did you solve the cipher yet? 
> I gave plenty of info by using the slide rule method and the actual private key and ciphertext associated with it.

I just ran an actual algorithm and the ciphertext has 2 corrections you are supposed to solve against the private 
alpha key.
When aligning an odd positioned group identifier from the public key it can only draw one letter from that group
in the private key string. This is because the left to right movement to align the identifier can't go back to the left
or stay in the same position on that identifier to choose the first but not the second letter within the same group.
So here is the corrected ciphertext with  4 corrections  --
5,7,1,2,6,1,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,2,2,4,2
It will be self-explanatory when you solve the cipher. 

[toc] | [prev] | [next] | [standalone]


#516328

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-01 22:42 -0700
Message-ID<s46ast$vru$1@gioia.aioe.org>
In reply to#516324
On 4/1/2021 9:55 PM, djoyce099 wrote:
> On Thursday, April 1, 2021 at 11:45:36 PM UTC-4, djoyce099 wrote:
>> On Thursday, April 1, 2021 at 7:58:28 PM UTC-4, Chris M. Thomasson wrote:
>>> On 4/1/2021 8:04 AM, djoyce099 wrote:
>>>> On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote:
>>>>> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote:
>>>>>> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote:
>>>>>>> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote:
>>>>>>>> On 3/31/2021 4:24 PM, James Waldby wrote:
>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>>>>>>> On 3/31/2021 1:55 PM, James Waldby wrote:
>>>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>>>>>>>>> On 3/30/2021 11:36 AM, djoyce099 wrote:
>>>>>>>>>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote:
>>>>>>>>>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote:
>>>>>>>>>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote:
>>>>>>>>>>> ...
>>>>>>>>>>>>>>>> Now wrt your work, can you decrypt this?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 17.4016863080244085
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It uses my simple idea of multiplying against a constant in the secret
>>>>>>>>>>>>>>>> key. You should post it there.
>>>>>>>>>>> ...
>>>>>>>>>>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are
>>>>>>>>>>>>>> different digits.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the
>>>>>>>>>>>>>> convergents of the original rational and use your initial mapping of
>>>>>>>>>>>>>> numbers to letters to decrypt the message.
>>>>>>>>>>> ...
>>>>>>>>>>>> 2. followed by three digits. So, its not 2.877
>>>>>>>>>>>
>>>>>>>>>>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x
>>>>>>>>>>> < y < z, the only word I see is `gab`, from divider 2.269.
>>>>>>>>>>
>>>>>>>>>> Its a number from 2.000 to 2.999. However, you need to divide
>>>>>>>>>> 17.4016863080244085 by it to get the original number that contains the
>>>>>>>>>> plaintext in its convergents. The answer is below, spoiler alert:
>>>>>>>>> ...
>>>>>>>>>>
>>>>>>>>>> ////
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> 17.4016863080244085 / 2.123 = 8.1967434328895
>>>>>>>>>>
>>>>>>>>>> 8.1967434328895 has the convergents:
>>>>>>>>>>
>>>>>>>>>> [8; 5 12 12 15]
>>>>>>>>>>
>>>>>>>>>> The plaintext is: hello
>>>>>>>>>>
>>>>>>>>>> ;^)
>>>>>>>>>
>>>>>>>>> Perhaps you didn't use arithmetic that was accurate enough?
>>>>>>>> Shit. Must have. The funny thing is that wolfram gives the convergents
>>>>>>>> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or
>>>>>>>> something.
>>>>>>>>
>>>>>>>> https://www.wolframalpha.com/input/?i=8.1967434328895
>>>>>>>>> The
>>>>>>>>> convergents actually are [8; 5 12 12 14 1 282893 ...], which my
>>>>>>>>> previously-mentioned continued-fractions-to-letters program showed as
>>>>>>>>> `hellna`, which is not found in usual dictionaries.
>>>>>>>>>
>>>>>>>>> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...]
>>>>>>> I am not sure how many digits in the decimal expansion of the target rational
>>>>>>> you need to compare to the number of terms in the cf.
>>>>>>> I way overdid it in my first post but it was a longer message that was encrypted but
>>>>>>> probably could have used a much smaller in length rational to get the desired number of
>>>>>>> of terms in the cf for the number to letter conversion.
>>>>>>>
>>>>>>> What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14..
>>>>>>> and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13..
>>>>>>> Think of it as using a slide rule where the private key
>>>>>>> (a string of random letters along with each group number identifiers) is on the fixed portion of the
>>>>>>> rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers.
>>>>>>> These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter
>>>>>>> with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted ---
>>>>>>> A letter is only used once in the left to right scan like the word little the first T in little is used then the
>>>>>>> scan continues by the decryptor for the second T because this private key string is made up of 49 alpha
>>>>>>> characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd
>>>>>>> count positions. Example below where this is easy to decrypt by just this simple method --
>>>>>>>
>>>>>>> ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ"
>>>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan )
>>>>>>> and scanning ----> again for the correct letter alignment to be cherry-picked from the private key.
>>>>>>> This is giving the whole cipher idea away but the order of the characters in the private key can be drastically
>>>>>>> changed along with the group identifiers then the public key would be useless to the person without the new private string.
>>>>>>> In a completed scan (end of too the right ------>), there could be several stops for letter alignments.
>>>>>>> I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done.
>>>>>>> The above decryption of the public key above is easy if you follow the rules.
>>>>>>> This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s
>>>>>>> that worked great for encrypting and decrypting these numbers only 1-7 ciphers.
>>>>>>> Just trying to transfer these thoughts into Python but not getting anywhere yet.
>>>>>> Has anyone figured out, what I call, my seven square cipher yet?
>>>>>> Or found any flaws in the concept?
>>>>> Adding a level of security to any public key cipher of the above nature the group identifiers could be changed
>>>>> to a different identifier position after each message sent.
>>>>> This way no patterns of odd position numbers can be detected even though some
>>>>> identifiers sometimes are used in succession breaking any pattern possible with future cipher messages.
>>>>>
>>>>> You may ask, why did I reveal the secrets to this cipher?
>>>>> Okay, Just say I presented the public key ---
>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7
>>>>> Then said, solve this cipher, what is the hidden written message these numbers represent?
>>>>> Duh, This is more powerful than even the German enigma machine.
>>>>> This is because the public key encoded numeric message can be any length but the
>>>>> private key is just 56 characters long. 1-7 group identifiers randomly located and the 49 Alpha characters.
>>>>> In other words, I would die with this secret. ;-)
>>>>
>>>> That was stupid of me, The above cipher can be solved by anyone knowing the rules and the private
>>>> key already revealed.
>>>>
>>> Also, if you are going to develop a cipher out of this, you need to make
>>> sure that every encryption generates a radically different ciphertext,
>>> even for the exact same plaintext. So encrypting the same plaintext
>>> several times in a row would produce very different ciphertexts.
>> Yes this is true, but because only 7 digits are used to pick an alpha character of 26 possibilities
>> only the order of these 7 group identifiers is changed after each message
>> The different combinations are 7! . A lot of messages (5048). Changed randomly. This way no letter connections
>> other than a few out of 7 letters in a few groups after a few messages are sent but then complete contradictory results
>> pointing to a letter involved with one particular identifier group of 7 letters.
>> A bunch of test ciphertext would have to be processed to prove this point.
>> The order right now of these group identifiers in this one example of the private key above is --- 3,5,1,6,2,7,4 and in
>> odd positions in the private key alpha string --- 1,9,17,25,33,41,49 whose position never changes.
>> 3,5,1,6,2,7,4 have 7! unique possibilities or (5040 possibilities) chosen from a random table of these possibilities.
>> So only a 7 number change is necessary and once in a while change the random order (predetermined in a certain
>> order of vowels and consonance strategically located in all the private string (groups of 7) should do the trick..
>> Did you solve the cipher yet?
>> I gave plenty of info by using the slide rule method and the actual private key and ciphertext associated with it.
> 
> I just ran an actual algorithm and the ciphertext has 2 corrections you are supposed to solve against the private
> alpha key.
> When aligning an odd positioned group identifier from the public key it can only draw one letter from that group
> in the private key string. This is because the left to right movement to align the identifier can't go back to the left
> or stay in the same position on that identifier to choose the first but not the second letter within the same group.
> So here is the corrected ciphertext with  4 corrections  --
> 5,7,1,2,6,1,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,2,2,4,2
> It will be self-explanatory when you solve the cipher.
> 

I am busy right now, but please post it over on sci.crypt.

Using the same exact secret key, and encrypting the plaintext several 
times in a row should create different ciphertexts. Here is a crude 
example I made of my highly experimental fractal based encryption 
algorihtm. This funny fractal thing is radically different than my HMAC 
cipher. Anyway...

Here are several ciphertexts that decrypt to the same exact plaintext 
using the default secret key using the following online program of mine:

http://funwithfractals.atspace.cc/ffe

The plaintext is: Hello World.

12 bytes


ciphertext 0
______________________________

0.07464055294813914 0.21413369654338263
0.18726842930653814 0.15381457747419044

13 65 3C 20 32 43 F4 50 66 9C 27 7A

______________________________


ciphertext 1
______________________________

0.10712703156460045 0.3825663517793289
0.3822450385558595 0.18493372431673

DF 2D 40 B5 C4 69 C0 C8 E8 9E 4C 99

______________________________


ciphertext 2
______________________________

0.4562359936711957 0.21850028449704323
0.3486656373192471 0.3596603216576378

4A 81 3D 5E 3F 26 F7 CF FD 15 83 15

______________________________



To decrypt, copy-and-paste the text in between the lines into the Cipher 
Text box and click the Decrypt button. Better to use a desktop for the 
crude layout.


This is using something called an IV. However, my HMAC cipher actually 
encrypts the random iv into the ciphertext itself. So, its not sent in 
the clear. Read all of:

http://funwithfractals.atspace.cc/ct_cipher

Also, read all of:

https://groups.google.com/g/comp.lang.c/c/a53VxN8cwkY/m/WIxIwoK7DAAJ


Actually, try clicking Encrypt multiple times and take a look at what 
happens to the ciphertext.

[toc] | [prev] | [next] | [standalone]


#516363

Fromdjoyce099 <hlauk.h.bogart@gmail.com>
Date2021-04-02 07:23 -0700
Message-ID<6f0c927d-29c7-4b00-92bd-75b49f347bddn@googlegroups.com>
In reply to#516328
On Friday, April 2, 2021 at 1:43:04 AM UTC-4, Chris M. Thomasson wrote:
> On 4/1/2021 9:55 PM, djoyce099 wrote: 
> > On Thursday, April 1, 2021 at 11:45:36 PM UTC-4, djoyce099 wrote: 
> >> On Thursday, April 1, 2021 at 7:58:28 PM UTC-4, Chris M. Thomasson wrote: 
> >>> On 4/1/2021 8:04 AM, djoyce099 wrote: 
> >>>> On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote: 
> >>>>> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote: 
> >>>>>> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote: 
> >>>>>>> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote: 
> >>>>>>>> On 3/31/2021 4:24 PM, James Waldby wrote: 
> >>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> >>>>>>>>>> On 3/31/2021 1:55 PM, James Waldby wrote: 
> >>>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> >>>>>>>>>>>> On 3/30/2021 11:36 AM, djoyce099 wrote: 
> >>>>>>>>>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote: 
> >>>>>>>>>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote: 
> >>>>>>>>>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote: 
> >>>>>>>>>>> ... 
> >>>>>>>>>>>>>>>> Now wrt your work, can you decrypt this? 
> >>>>>>>>>>>>>>>> 
> >>>>>>>>>>>>>>>> 17.4016863080244085 
> >>>>>>>>>>>>>>>> 
> >>>>>>>>>>>>>>>> It uses my simple idea of multiplying against a constant in the secret 
> >>>>>>>>>>>>>>>> key. You should post it there. 
> >>>>>>>>>>> ... 
> >>>>>>>>>>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are 
> >>>>>>>>>>>>>> different digits. 
> >>>>>>>>>>>>>> 
> >>>>>>>>>>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the 
> >>>>>>>>>>>>>> convergents of the original rational and use your initial mapping of 
> >>>>>>>>>>>>>> numbers to letters to decrypt the message. 
> >>>>>>>>>>> ... 
> >>>>>>>>>>>> 2. followed by three digits. So, its not 2.877 
> >>>>>>>>>>> 
> >>>>>>>>>>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x 
> >>>>>>>>>>> < y < z, the only word I see is `gab`, from divider 2.269. 
> >>>>>>>>>> 
> >>>>>>>>>> Its a number from 2.000 to 2.999. However, you need to divide 
> >>>>>>>>>> 17.4016863080244085 by it to get the original number that contains the 
> >>>>>>>>>> plaintext in its convergents. The answer is below, spoiler alert: 
> >>>>>>>>> ... 
> >>>>>>>>>> 
> >>>>>>>>>> //// 
> >>>>>>>>>> 
> >>>>>>>>>> 
> >>>>>>>>>> 
> >>>>>>>>>> 17.4016863080244085 / 2.123 = 8.1967434328895 
> >>>>>>>>>> 
> >>>>>>>>>> 8.1967434328895 has the convergents: 
> >>>>>>>>>> 
> >>>>>>>>>> [8; 5 12 12 15] 
> >>>>>>>>>> 
> >>>>>>>>>> The plaintext is: hello 
> >>>>>>>>>> 
> >>>>>>>>>> ;^) 
> >>>>>>>>> 
> >>>>>>>>> Perhaps you didn't use arithmetic that was accurate enough? 
> >>>>>>>> Shit. Must have. The funny thing is that wolfram gives the convergents 
> >>>>>>>> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or 
> >>>>>>>> something. 
> >>>>>>>> 
> >>>>>>>> https://www.wolframalpha.com/input/?i=8.1967434328895 
> >>>>>>>>> The 
> >>>>>>>>> convergents actually are [8; 5 12 12 14 1 282893 ...], which my 
> >>>>>>>>> previously-mentioned continued-fractions-to-letters program showed as 
> >>>>>>>>> `hellna`, which is not found in usual dictionaries. 
> >>>>>>>>> 
> >>>>>>>>> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...] 
> >>>>>>> I am not sure how many digits in the decimal expansion of the target rational 
> >>>>>>> you need to compare to the number of terms in the cf. 
> >>>>>>> I way overdid it in my first post but it was a longer message that was encrypted but 
> >>>>>>> probably could have used a much smaller in length rational to get the desired number of 
> >>>>>>> of terms in the cf for the number to letter conversion. 
> >>>>>>> 
> >>>>>>> What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14.. 
> >>>>>>> and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13.. 
> >>>>>>> Think of it as using a slide rule where the private key 
> >>>>>>> (a string of random letters along with each group number identifiers) is on the fixed portion of the 
> >>>>>>> rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers. 
> >>>>>>> These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter 
> >>>>>>> with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted --- 
> >>>>>>> A letter is only used once in the left to right scan like the word little the first T in little is used then the 
> >>>>>>> scan continues by the decryptor for the second T because this private key string is made up of 49 alpha 
> >>>>>>> characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd 
> >>>>>>> count positions. Example below where this is easy to decrypt by just this simple method -- 
> >>>>>>> 
> >>>>>>> ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ" 
> >>>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan ) 
> >>>>>>> and scanning ----> again for the correct letter alignment to be cherry-picked from the private key. 
> >>>>>>> This is giving the whole cipher idea away but the order of the characters in the private key can be drastically 
> >>>>>>> changed along with the group identifiers then the public key would be useless to the person without the new private string. 
> >>>>>>> In a completed scan (end of too the right ------>), there could be several stops for letter alignments. 
> >>>>>>> I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done. 
> >>>>>>> The above decryption of the public key above is easy if you follow the rules. 
> >>>>>>> This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s 
> >>>>>>> that worked great for encrypting and decrypting these numbers only 1-7 ciphers. 
> >>>>>>> Just trying to transfer these thoughts into Python but not getting anywhere yet. 
> >>>>>> Has anyone figured out, what I call, my seven square cipher yet? 
> >>>>>> Or found any flaws in the concept? 
> >>>>> Adding a level of security to any public key cipher of the above nature the group identifiers could be changed 
> >>>>> to a different identifier position after each message sent. 
> >>>>> This way no patterns of odd position numbers can be detected even though some 
> >>>>> identifiers sometimes are used in succession breaking any pattern possible with future cipher messages. 
> >>>>> 
> >>>>> You may ask, why did I reveal the secrets to this cipher? 
> >>>>> Okay, Just say I presented the public key --- 
> >>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 
> >>>>> Then said, solve this cipher, what is the hidden written message these numbers represent? 
> >>>>> Duh, This is more powerful than even the German enigma machine. 
> >>>>> This is because the public key encoded numeric message can be any length but the 
> >>>>> private key is just 56 characters long. 1-7 group identifiers randomly located and the 49 Alpha characters. 
> >>>>> In other words, I would die with this secret. ;-) 
> >>>> 
> >>>> That was stupid of me, The above cipher can be solved by anyone knowing the rules and the private 
> >>>> key already revealed. 
> >>>> 
> >>> Also, if you are going to develop a cipher out of this, you need to make 
> >>> sure that every encryption generates a radically different ciphertext, 
> >>> even for the exact same plaintext. So encrypting the same plaintext 
> >>> several times in a row would produce very different ciphertexts. 
> >> Yes this is true, but because only 7 digits are used to pick an alpha character of 26 possibilities 
> >> only the order of these 7 group identifiers is changed after each message 
> >> The different combinations are 7! . A lot of messages (5048). Changed randomly. This way no letter connections 
> >> other than a few out of 7 letters in a few groups after a few messages are sent but then complete contradictory results 
> >> pointing to a letter involved with one particular identifier group of 7 letters. 
> >> A bunch of test ciphertext would have to be processed to prove this point. 
> >> The order right now of these group identifiers in this one example of the private key above is --- 3,5,1,6,2,7,4 and in 
> >> odd positions in the private key alpha string --- 1,9,17,25,33,41,49 whose position never changes. 
> >> 3,5,1,6,2,7,4 have 7! unique possibilities or (5040 possibilities) chosen from a random table of these possibilities. 
> >> So only a 7 number change is necessary and once in a while change the random order (predetermined in a certain 
> >> order of vowels and consonance strategically located in all the private string (groups of 7) should do the trick.. 
> >> Did you solve the cipher yet? 
> >> I gave plenty of info by using the slide rule method and the actual private key and ciphertext associated with it. 
> > 
> > I just ran an actual algorithm and the ciphertext has 2 corrections you are supposed to solve against the private 
> > alpha key. 
> > When aligning an odd positioned group identifier from the public key it can only draw one letter from that group 
> > in the private key string. This is because the left to right movement to align the identifier can't go back to the left 
> > or stay in the same position on that identifier to choose the first but not the second letter within the same group. 
> > So here is the corrected ciphertext with 4 corrections -- 
> > 5,7,1,2,6,1,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,2,2,4,2 
> > It will be self-explanatory when you solve the cipher. 
> >
> I am busy right now, but please post it over on sci.crypt. 
> 
> Using the same exact secret key, and encrypting the plaintext several 
> times in a row should create different ciphertexts. Here is a crude 
> example I made of my highly experimental fractal based encryption 
> algorihtm. This funny fractal thing is radically different than my HMAC 
> cipher. Anyway... 
> 
> Here are several ciphertexts that decrypt to the same exact plaintext 
> using the default secret key using the following online program of mine: 
> 
> http://funwithfractals.atspace.cc/ffe 
> 
> The plaintext is: Hello World. 
> 
> 12 bytes 
> 
> 
> ciphertext 0 
> ______________________________ 
> 
> 0.07464055294813914 0.21413369654338263 
> 0.18726842930653814 0.15381457747419044 
> 
> 13 65 3C 20 32 43 F4 50 66 9C 27 7A 
> 
> ______________________________ 
> 
> 
> ciphertext 1 
> ______________________________ 
> 
> 0.10712703156460045 0.3825663517793289 
> 0.3822450385558595 0.18493372431673 
> 
> DF 2D 40 B5 C4 69 C0 C8 E8 9E 4C 99 
> 
> ______________________________ 
> 
> 
> ciphertext 2 
> ______________________________ 
> 
> 0.4562359936711957 0.21850028449704323 
> 0.3486656373192471 0.3596603216576378 
> 
> 4A 81 3D 5E 3F 26 F7 CF FD 15 83 15 
> 
> ______________________________ 
> 
> 
> 
> To decrypt, copy-and-paste the text in between the lines into the Cipher 
> Text box and click the Decrypt button. Better to use a desktop for the 
> crude layout. 
> 
> 
> This is using something called an IV. However, my HMAC cipher actually 
> encrypts the random iv into the ciphertext itself. So, its not sent in 
> the clear. Read all of: 
> 
> http://funwithfractals.atspace.cc/ct_cipher 
> 
> Also, read all of: 
> 
> https://groups.google.com/g/comp.lang.c/c/a53VxN8cwkY/m/WIxIwoK7DAAJ 
> 
> 
> Actually, try clicking Encrypt multiple times and take a look at what 
> happens to the ciphertext.

I put in --- thelittlebrowndogsquicklyjumpedoverthelazyfox  
All the letters of the alphabet.
Some of the different renderings it creates is fantastic.
Genious.
I have not a clue of what you are doing but it is way over my head.

[toc] | [prev] | [next] | [standalone]


#516373

Fromdjoyce099 <hlauk.h.bogart@gmail.com>
Date2021-04-02 08:00 -0700
Message-ID<beb73724-3942-4c17-a32f-0a28267701dbn@googlegroups.com>
In reply to#516363
On Friday, April 2, 2021 at 10:23:47 AM UTC-4, djoyce099 wrote:
> On Friday, April 2, 2021 at 1:43:04 AM UTC-4, Chris M. Thomasson wrote: 
> > On 4/1/2021 9:55 PM, djoyce099 wrote: 
> > > On Thursday, April 1, 2021 at 11:45:36 PM UTC-4, djoyce099 wrote: 
> > >> On Thursday, April 1, 2021 at 7:58:28 PM UTC-4, Chris M. Thomasson wrote: 
> > >>> On 4/1/2021 8:04 AM, djoyce099 wrote: 
> > >>>> On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote: 
> > >>>>> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote: 
> > >>>>>> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote: 
> > >>>>>>> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote: 
> > >>>>>>>> On 3/31/2021 4:24 PM, James Waldby wrote: 
> > >>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> > >>>>>>>>>> On 3/31/2021 1:55 PM, James Waldby wrote: 
> > >>>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> > >>>>>>>>>>>> On 3/30/2021 11:36 AM, djoyce099 wrote: 
> > >>>>>>>>>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote: 
> > >>>>>>>>>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote: 
> > >>>>>>>>>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote: 
> > >>>>>>>>>>> ... 
> > >>>>>>>>>>>>>>>> Now wrt your work, can you decrypt this? 
> > >>>>>>>>>>>>>>>> 
> > >>>>>>>>>>>>>>>> 17.4016863080244085 
> > >>>>>>>>>>>>>>>> 
> > >>>>>>>>>>>>>>>> It uses my simple idea of multiplying against a constant in the secret 
> > >>>>>>>>>>>>>>>> key. You should post it there. 
> > >>>>>>>>>>> ... 
> > >>>>>>>>>>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are 
> > >>>>>>>>>>>>>> different digits. 
> > >>>>>>>>>>>>>> 
> > >>>>>>>>>>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the 
> > >>>>>>>>>>>>>> convergents of the original rational and use your initial mapping of 
> > >>>>>>>>>>>>>> numbers to letters to decrypt the message. 
> > >>>>>>>>>>> ... 
> > >>>>>>>>>>>> 2. followed by three digits. So, its not 2.877 
> > >>>>>>>>>>> 
> > >>>>>>>>>>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x 
> > >>>>>>>>>>> < y < z, the only word I see is `gab`, from divider 2.269. 
> > >>>>>>>>>> 
> > >>>>>>>>>> Its a number from 2.000 to 2.999. However, you need to divide 
> > >>>>>>>>>> 17.4016863080244085 by it to get the original number that contains the 
> > >>>>>>>>>> plaintext in its convergents. The answer is below, spoiler alert: 
> > >>>>>>>>> ... 
> > >>>>>>>>>> 
> > >>>>>>>>>> //// 
> > >>>>>>>>>> 
> > >>>>>>>>>> 
> > >>>>>>>>>> 
> > >>>>>>>>>> 17.4016863080244085 / 2.123 = 8.1967434328895 
> > >>>>>>>>>> 
> > >>>>>>>>>> 8.1967434328895 has the convergents: 
> > >>>>>>>>>> 
> > >>>>>>>>>> [8; 5 12 12 15] 
> > >>>>>>>>>> 
> > >>>>>>>>>> The plaintext is: hello 
> > >>>>>>>>>> 
> > >>>>>>>>>> ;^) 
> > >>>>>>>>> 
> > >>>>>>>>> Perhaps you didn't use arithmetic that was accurate enough? 
> > >>>>>>>> Shit. Must have. The funny thing is that wolfram gives the convergents 
> > >>>>>>>> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or 
> > >>>>>>>> something. 
> > >>>>>>>> 
> > >>>>>>>> https://www.wolframalpha.com/input/?i=8.1967434328895 
> > >>>>>>>>> The 
> > >>>>>>>>> convergents actually are [8; 5 12 12 14 1 282893 ...], which my 
> > >>>>>>>>> previously-mentioned continued-fractions-to-letters program showed as 
> > >>>>>>>>> `hellna`, which is not found in usual dictionaries. 
> > >>>>>>>>> 
> > >>>>>>>>> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...] 
> > >>>>>>> I am not sure how many digits in the decimal expansion of the target rational 
> > >>>>>>> you need to compare to the number of terms in the cf. 
> > >>>>>>> I way overdid it in my first post but it was a longer message that was encrypted but 
> > >>>>>>> probably could have used a much smaller in length rational to get the desired number of 
> > >>>>>>> of terms in the cf for the number to letter conversion. 
> > >>>>>>> 
> > >>>>>>> What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14.. 
> > >>>>>>> and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13.. 
> > >>>>>>> Think of it as using a slide rule where the private key 
> > >>>>>>> (a string of random letters along with each group number identifiers) is on the fixed portion of the 
> > >>>>>>> rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers. 
> > >>>>>>> These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter 
> > >>>>>>> with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted --- 
> > >>>>>>> A letter is only used once in the left to right scan like the word little the first T in little is used then the 
> > >>>>>>> scan continues by the decryptor for the second T because this private key string is made up of 49 alpha 
> > >>>>>>> characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd 
> > >>>>>>> count positions. Example below where this is easy to decrypt by just this simple method -- 
> > >>>>>>> 
> > >>>>>>> ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ" 
> > >>>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan ) 
> > >>>>>>> and scanning ----> again for the correct letter alignment to be cherry-picked from the private key. 
> > >>>>>>> This is giving the whole cipher idea away but the order of the characters in the private key can be drastically 
> > >>>>>>> changed along with the group identifiers then the public key would be useless to the person without the new private string. 
> > >>>>>>> In a completed scan (end of too the right ------>), there could be several stops for letter alignments. 
> > >>>>>>> I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done. 
> > >>>>>>> The above decryption of the public key above is easy if you follow the rules. 
> > >>>>>>> This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s 
> > >>>>>>> that worked great for encrypting and decrypting these numbers only 1-7 ciphers. 
> > >>>>>>> Just trying to transfer these thoughts into Python but not getting anywhere yet. 
> > >>>>>> Has anyone figured out, what I call, my seven square cipher yet? 
> > >>>>>> Or found any flaws in the concept? 
> > >>>>> Adding a level of security to any public key cipher of the above nature the group identifiers could be changed 
> > >>>>> to a different identifier position after each message sent. 
> > >>>>> This way no patterns of odd position numbers can be detected even though some 
> > >>>>> identifiers sometimes are used in succession breaking any pattern possible with future cipher messages. 
> > >>>>> 
> > >>>>> You may ask, why did I reveal the secrets to this cipher? 
> > >>>>> Okay, Just say I presented the public key --- 
> > >>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 
> > >>>>> Then said, solve this cipher, what is the hidden written message these numbers represent? 
> > >>>>> Duh, This is more powerful than even the German enigma machine. 
> > >>>>> This is because the public key encoded numeric message can be any length but the 
> > >>>>> private key is just 56 characters long. 1-7 group identifiers randomly located and the 49 Alpha characters. 
> > >>>>> In other words, I would die with this secret. ;-) 
> > >>>> 
> > >>>> That was stupid of me, The above cipher can be solved by anyone knowing the rules and the private 
> > >>>> key already revealed. 
> > >>>> 
> > >>> Also, if you are going to develop a cipher out of this, you need to make 
> > >>> sure that every encryption generates a radically different ciphertext, 
> > >>> even for the exact same plaintext. So encrypting the same plaintext 
> > >>> several times in a row would produce very different ciphertexts. 
> > >> Yes this is true, but because only 7 digits are used to pick an alpha character of 26 possibilities 
> > >> only the order of these 7 group identifiers is changed after each message 
> > >> The different combinations are 7! . A lot of messages (5048). Changed randomly. This way no letter connections 
> > >> other than a few out of 7 letters in a few groups after a few messages are sent but then complete contradictory results 
> > >> pointing to a letter involved with one particular identifier group of 7 letters. 
> > >> A bunch of test ciphertext would have to be processed to prove this point. 
> > >> The order right now of these group identifiers in this one example of the private key above is --- 3,5,1,6,2,7,4 and in 
> > >> odd positions in the private key alpha string --- 1,9,17,25,33,41,49 whose position never changes. 
> > >> 3,5,1,6,2,7,4 have 7! unique possibilities or (5040 possibilities) chosen from a random table of these possibilities. 
> > >> So only a 7 number change is necessary and once in a while change the random order (predetermined in a certain 
> > >> order of vowels and consonance strategically located in all the private string (groups of 7) should do the trick.. 
> > >> Did you solve the cipher yet? 
> > >> I gave plenty of info by using the slide rule method and the actual private key and ciphertext associated with it. 
> > > 
> > > I just ran an actual algorithm and the ciphertext has 2 corrections you are supposed to solve against the private 
> > > alpha key. 
> > > When aligning an odd positioned group identifier from the public key it can only draw one letter from that group 
> > > in the private key string. This is because the left to right movement to align the identifier can't go back to the left 
> > > or stay in the same position on that identifier to choose the first but not the second letter within the same group. 
> > > So here is the corrected ciphertext with 4 corrections -- 
> > > 5,7,1,2,6,1,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,2,2,4,2 
> > > It will be self-explanatory when you solve the cipher. 
> > > 
> > I am busy right now, but please post it over on sci.crypt. 
> > 
> > Using the same exact secret key, and encrypting the plaintext several 
> > times in a row should create different ciphertexts. Here is a crude 
> > example I made of my highly experimental fractal based encryption 
> > algorihtm. This funny fractal thing is radically different than my HMAC 
> > cipher. Anyway... 
> > 
> > Here are several ciphertexts that decrypt to the same exact plaintext 
> > using the default secret key using the following online program of mine: 
> > 
> > http://funwithfractals.atspace.cc/ffe 
> > 
> > The plaintext is: Hello World. 
> > 
> > 12 bytes 
> > 
> > 
> > ciphertext 0 
> > ______________________________ 
> > 
> > 0.07464055294813914 0.21413369654338263 
> > 0.18726842930653814 0.15381457747419044 
> > 
> > 13 65 3C 20 32 43 F4 50 66 9C 27 7A 
> > 
> > ______________________________ 
> > 
> > 
> > ciphertext 1 
> > ______________________________ 
> > 
> > 0.10712703156460045 0.3825663517793289 
> > 0.3822450385558595 0.18493372431673 
> > 
> > DF 2D 40 B5 C4 69 C0 C8 E8 9E 4C 99 
> > 
> > ______________________________ 
> > 
> > 
> > ciphertext 2 
> > ______________________________ 
> > 
> > 0.4562359936711957 0.21850028449704323 
> > 0.3486656373192471 0.3596603216576378 
> > 
> > 4A 81 3D 5E 3F 26 F7 CF FD 15 83 15 
> > 
> > ______________________________ 
> > 
> > 
> > 
> > To decrypt, copy-and-paste the text in between the lines into the Cipher 
> > Text box and click the Decrypt button. Better to use a desktop for the 
> > crude layout. 
> > 
> > 
> > This is using something called an IV. However, my HMAC cipher actually 
> > encrypts the random iv into the ciphertext itself. So, its not sent in 
> > the clear. Read all of: 
> > 
> > http://funwithfractals.atspace.cc/ct_cipher 
> > 
> > Also, read all of: 
> > 
> > https://groups.google.com/g/comp.lang.c/c/a53VxN8cwkY/m/WIxIwoK7DAAJ 
> > 
> > 
> > Actually, try clicking Encrypt multiple times and take a look at what 
> > happens to the ciphertext.
> I put in --- thelittlebrowndogsquicklyjumpedoverthelazyfox 
> All the letters of the alphabet. 
> Some of the different renderings it creates is fantastic. 
> Genious. 
> I have not a clue of what you are doing but it is way over my head.

Can you enlarge the renderings?
That would be impressive to see what a simple sentence creates.
I will have to take some time to study what you are doing.
Thanks for this brilliant idea.

[toc] | [prev] | [next] | [standalone]


#516376

Fromdjoyce099 <hlauk.h.bogart@gmail.com>
Date2021-04-02 08:42 -0700
Message-ID<88260bf5-8fe3-4159-9154-4fcb625b8f69n@googlegroups.com>
In reply to#516373
On Friday, April 2, 2021 at 11:00:53 AM UTC-4, djoyce099 wrote:
> On Friday, April 2, 2021 at 10:23:47 AM UTC-4, djoyce099 wrote: 
> > On Friday, April 2, 2021 at 1:43:04 AM UTC-4, Chris M. Thomasson wrote: 
> > > On 4/1/2021 9:55 PM, djoyce099 wrote: 
> > > > On Thursday, April 1, 2021 at 11:45:36 PM UTC-4, djoyce099 wrote: 
> > > >> On Thursday, April 1, 2021 at 7:58:28 PM UTC-4, Chris M. Thomasson wrote: 
> > > >>> On 4/1/2021 8:04 AM, djoyce099 wrote: 
> > > >>>> On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote: 
> > > >>>>> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote: 
> > > >>>>>> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote: 
> > > >>>>>>> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote: 
> > > >>>>>>>> On 3/31/2021 4:24 PM, James Waldby wrote: 
> > > >>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> > > >>>>>>>>>> On 3/31/2021 1:55 PM, James Waldby wrote: 
> > > >>>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> > > >>>>>>>>>>>> On 3/30/2021 11:36 AM, djoyce099 wrote: 
> > > >>>>>>>>>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote: 
> > > >>>>>>>>>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote: 
> > > >>>>>>>>>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote: 
> > > >>>>>>>>>>> ... 
> > > >>>>>>>>>>>>>>>> Now wrt your work, can you decrypt this? 
> > > >>>>>>>>>>>>>>>> 
> > > >>>>>>>>>>>>>>>> 17.4016863080244085 
> > > >>>>>>>>>>>>>>>> 
> > > >>>>>>>>>>>>>>>> It uses my simple idea of multiplying against a constant in the secret 
> > > >>>>>>>>>>>>>>>> key. You should post it there. 
> > > >>>>>>>>>>> ... 
> > > >>>>>>>>>>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are 
> > > >>>>>>>>>>>>>> different digits. 
> > > >>>>>>>>>>>>>> 
> > > >>>>>>>>>>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the 
> > > >>>>>>>>>>>>>> convergents of the original rational and use your initial mapping of 
> > > >>>>>>>>>>>>>> numbers to letters to decrypt the message. 
> > > >>>>>>>>>>> ... 
> > > >>>>>>>>>>>> 2. followed by three digits. So, its not 2.877 
> > > >>>>>>>>>>> 
> > > >>>>>>>>>>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x 
> > > >>>>>>>>>>> < y < z, the only word I see is `gab`, from divider 2.269. 
> > > >>>>>>>>>> 
> > > >>>>>>>>>> Its a number from 2.000 to 2.999. However, you need to divide 
> > > >>>>>>>>>> 17.4016863080244085 by it to get the original number that contains the 
> > > >>>>>>>>>> plaintext in its convergents. The answer is below, spoiler alert: 
> > > >>>>>>>>> ... 
> > > >>>>>>>>>> 
> > > >>>>>>>>>> //// 
> > > >>>>>>>>>> 
> > > >>>>>>>>>> 
> > > >>>>>>>>>> 
> > > >>>>>>>>>> 17.4016863080244085 / 2.123 = 8.1967434328895 
> > > >>>>>>>>>> 
> > > >>>>>>>>>> 8.1967434328895 has the convergents: 
> > > >>>>>>>>>> 
> > > >>>>>>>>>> [8; 5 12 12 15] 
> > > >>>>>>>>>> 
> > > >>>>>>>>>> The plaintext is: hello 
> > > >>>>>>>>>> 
> > > >>>>>>>>>> ;^) 
> > > >>>>>>>>> 
> > > >>>>>>>>> Perhaps you didn't use arithmetic that was accurate enough? 
> > > >>>>>>>> Shit. Must have. The funny thing is that wolfram gives the convergents 
> > > >>>>>>>> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or 
> > > >>>>>>>> something. 
> > > >>>>>>>> 
> > > >>>>>>>> https://www.wolframalpha.com/input/?i=8.1967434328895 
> > > >>>>>>>>> The 
> > > >>>>>>>>> convergents actually are [8; 5 12 12 14 1 282893 ...], which my 
> > > >>>>>>>>> previously-mentioned continued-fractions-to-letters program showed as 
> > > >>>>>>>>> `hellna`, which is not found in usual dictionaries. 
> > > >>>>>>>>> 
> > > >>>>>>>>> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...] 
> > > >>>>>>> I am not sure how many digits in the decimal expansion of the target rational 
> > > >>>>>>> you need to compare to the number of terms in the cf. 
> > > >>>>>>> I way overdid it in my first post but it was a longer message that was encrypted but 
> > > >>>>>>> probably could have used a much smaller in length rational to get the desired number of 
> > > >>>>>>> of terms in the cf for the number to letter conversion. 
> > > >>>>>>> 
> > > >>>>>>> What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14.. 
> > > >>>>>>> and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13.. 
> > > >>>>>>> Think of it as using a slide rule where the private key 
> > > >>>>>>> (a string of random letters along with each group number identifiers) is on the fixed portion of the 
> > > >>>>>>> rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers. 
> > > >>>>>>> These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter 
> > > >>>>>>> with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted --- 
> > > >>>>>>> A letter is only used once in the left to right scan like the word little the first T in little is used then the 
> > > >>>>>>> scan continues by the decryptor for the second T because this private key string is made up of 49 alpha 
> > > >>>>>>> characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd 
> > > >>>>>>> count positions. Example below where this is easy to decrypt by just this simple method -- 
> > > >>>>>>> 
> > > >>>>>>> ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ" 
> > > >>>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan ) 
> > > >>>>>>> and scanning ----> again for the correct letter alignment to be cherry-picked from the private key. 
> > > >>>>>>> This is giving the whole cipher idea away but the order of the characters in the private key can be drastically 
> > > >>>>>>> changed along with the group identifiers then the public key would be useless to the person without the new private string. 
> > > >>>>>>> In a completed scan (end of too the right ------>), there could be several stops for letter alignments. 
> > > >>>>>>> I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done. 
> > > >>>>>>> The above decryption of the public key above is easy if you follow the rules. 
> > > >>>>>>> This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s 
> > > >>>>>>> that worked great for encrypting and decrypting these numbers only 1-7 ciphers. 
> > > >>>>>>> Just trying to transfer these thoughts into Python but not getting anywhere yet. 
> > > >>>>>> Has anyone figured out, what I call, my seven square cipher yet? 
> > > >>>>>> Or found any flaws in the concept? 
> > > >>>>> Adding a level of security to any public key cipher of the above nature the group identifiers could be changed 
> > > >>>>> to a different identifier position after each message sent. 
> > > >>>>> This way no patterns of odd position numbers can be detected even though some 
> > > >>>>> identifiers sometimes are used in succession breaking any pattern possible with future cipher messages. 
> > > >>>>> 
> > > >>>>> You may ask, why did I reveal the secrets to this cipher? 
> > > >>>>> Okay, Just say I presented the public key --- 
> > > >>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 
> > > >>>>> Then said, solve this cipher, what is the hidden written message these numbers represent? 
> > > >>>>> Duh, This is more powerful than even the German enigma machine. 
> > > >>>>> This is because the public key encoded numeric message can be any length but the 
> > > >>>>> private key is just 56 characters long. 1-7 group identifiers randomly located and the 49 Alpha characters. 
> > > >>>>> In other words, I would die with this secret. ;-) 
> > > >>>> 
> > > >>>> That was stupid of me, The above cipher can be solved by anyone knowing the rules and the private 
> > > >>>> key already revealed. 
> > > >>>> 
> > > >>> Also, if you are going to develop a cipher out of this, you need to make 
> > > >>> sure that every encryption generates a radically different ciphertext, 
> > > >>> even for the exact same plaintext. So encrypting the same plaintext 
> > > >>> several times in a row would produce very different ciphertexts. 
> > > >> Yes this is true, but because only 7 digits are used to pick an alpha character of 26 possibilities 
> > > >> only the order of these 7 group identifiers is changed after each message 
> > > >> The different combinations are 7! . A lot of messages (5048). Changed randomly. This way no letter connections 
> > > >> other than a few out of 7 letters in a few groups after a few messages are sent but then complete contradictory results 
> > > >> pointing to a letter involved with one particular identifier group of 7 letters. 
> > > >> A bunch of test ciphertext would have to be processed to prove this point. 
> > > >> The order right now of these group identifiers in this one example of the private key above is --- 3,5,1,6,2,7,4 and in 
> > > >> odd positions in the private key alpha string --- 1,9,17,25,33,41,49 whose position never changes. 
> > > >> 3,5,1,6,2,7,4 have 7! unique possibilities or (5040 possibilities) chosen from a random table of these possibilities. 
> > > >> So only a 7 number change is necessary and once in a while change the random order (predetermined in a certain 
> > > >> order of vowels and consonance strategically located in all the private string (groups of 7) should do the trick.. 
> > > >> Did you solve the cipher yet? 
> > > >> I gave plenty of info by using the slide rule method and the actual private key and ciphertext associated with it. 
> > > > 
> > > > I just ran an actual algorithm and the ciphertext has 2 corrections you are supposed to solve against the private 
> > > > alpha key. 
> > > > When aligning an odd positioned group identifier from the public key it can only draw one letter from that group 
> > > > in the private key string. This is because the left to right movement to align the identifier can't go back to the left 
> > > > or stay in the same position on that identifier to choose the first but not the second letter within the same group. 
> > > > So here is the corrected ciphertext with 4 corrections -- 
> > > > 5,7,1,2,6,1,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,2,2,4,2 
> > > > It will be self-explanatory when you solve the cipher. 
> > > > 
> > > I am busy right now, but please post it over on sci.crypt. 
> > > 
> > > Using the same exact secret key, and encrypting the plaintext several 
> > > times in a row should create different ciphertexts. Here is a crude 
> > > example I made of my highly experimental fractal based encryption 
> > > algorihtm. This funny fractal thing is radically different than my HMAC 
> > > cipher. Anyway... 
> > > 
> > > Here are several ciphertexts that decrypt to the same exact plaintext 
> > > using the default secret key using the following online program of mine: 
> > > 
> > > http://funwithfractals.atspace.cc/ffe 
> > > 
> > > The plaintext is: Hello World. 
> > > 
> > > 12 bytes 
> > > 
> > > 
> > > ciphertext 0 
> > > ______________________________ 
> > > 
> > > 0.07464055294813914 0.21413369654338263 
> > > 0.18726842930653814 0.15381457747419044 
> > > 
> > > 13 65 3C 20 32 43 F4 50 66 9C 27 7A 
> > > 
> > > ______________________________ 
> > > 
> > > 
> > > ciphertext 1 
> > > ______________________________ 
> > > 
> > > 0.10712703156460045 0.3825663517793289 
> > > 0.3822450385558595 0.18493372431673 
> > > 
> > > DF 2D 40 B5 C4 69 C0 C8 E8 9E 4C 99 
> > > 
> > > ______________________________ 
> > > 
> > > 
> > > ciphertext 2 
> > > ______________________________ 
> > > 
> > > 0.4562359936711957 0.21850028449704323 
> > > 0.3486656373192471 0.3596603216576378 
> > > 
> > > 4A 81 3D 5E 3F 26 F7 CF FD 15 83 15 
> > > 
> > > ______________________________ 
> > > 
> > > 
> > > 
> > > To decrypt, copy-and-paste the text in between the lines into the Cipher 
> > > Text box and click the Decrypt button. Better to use a desktop for the 
> > > crude layout. 
> > > 
> > > 
> > > This is using something called an IV. However, my HMAC cipher actually 
> > > encrypts the random iv into the ciphertext itself. So, its not sent in 
> > > the clear. Read all of: 
> > > 
> > > http://funwithfractals.atspace.cc/ct_cipher 
> > > 
> > > Also, read all of: 
> > > 
> > > https://groups.google.com/g/comp.lang.c/c/a53VxN8cwkY/m/WIxIwoK7DAAJ 
> > > 
> > > 
> > > Actually, try clicking Encrypt multiple times and take a look at what 
> > > happens to the ciphertext. 
> > I put in --- thelittlebrowndogsquicklyjumpedoverthelazyfox 
> > All the letters of the alphabet. 
> > Some of the different renderings it creates is fantastic. 
> > Genious. 
> > I have not a clue of what you are doing but it is way over my head.
> Can you enlarge the renderings? 
> That would be impressive to see what a simple sentence creates. 
> I will have to take some time to study what you are doing. 
> Thanks for this brilliant idea.
 
Makes my idea look like Childs play.
Reminds me of an old TV show -- Can You Top This.

[toc] | [prev] | [next] | [standalone]


#516507

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-03 12:05 -0700
Message-ID<s4aeab$1g0t$1@gioia.aioe.org>
In reply to#516373
On 4/2/2021 8:00 AM, djoyce099 wrote:
> On Friday, April 2, 2021 at 10:23:47 AM UTC-4, djoyce099 wrote:
>> On Friday, April 2, 2021 at 1:43:04 AM UTC-4, Chris M. Thomasson wrote:
>>> On 4/1/2021 9:55 PM, djoyce099 wrote:
>>>> On Thursday, April 1, 2021 at 11:45:36 PM UTC-4, djoyce099 wrote:
>>>>> On Thursday, April 1, 2021 at 7:58:28 PM UTC-4, Chris M. Thomasson wrote:
>>>>>> On 4/1/2021 8:04 AM, djoyce099 wrote:
>>>>>>> On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote:
>>>>>>>> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote:
>>>>>>>>> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote:
>>>>>>>>>> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote:
>>>>>>>>>>> On 3/31/2021 4:24 PM, James Waldby wrote:
>>>>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>>>>>>>>>> On 3/31/2021 1:55 PM, James Waldby wrote:
>>>>>>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>>>>>>>>>>>> On 3/30/2021 11:36 AM, djoyce099 wrote:
>>>>>>>>>>>>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote:
>>>>>>>>>>>>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote:
>>>>>>>>>>>>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote:
>>>>>>>>>>>>>> ...
>>>>>>>>>>>>>>>>>>> Now wrt your work, can you decrypt this?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 17.4016863080244085
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It uses my simple idea of multiplying against a constant in the secret
>>>>>>>>>>>>>>>>>>> key. You should post it there.
>>>>>>>>>>>>>> ...
>>>>>>>>>>>>>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are
>>>>>>>>>>>>>>>>> different digits.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the
>>>>>>>>>>>>>>>>> convergents of the original rational and use your initial mapping of
>>>>>>>>>>>>>>>>> numbers to letters to decrypt the message.
>>>>>>>>>>>>>> ...
>>>>>>>>>>>>>>> 2. followed by three digits. So, its not 2.877
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x
>>>>>>>>>>>>>> < y < z, the only word I see is `gab`, from divider 2.269.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Its a number from 2.000 to 2.999. However, you need to divide
>>>>>>>>>>>>> 17.4016863080244085 by it to get the original number that contains the
>>>>>>>>>>>>> plaintext in its convergents. The answer is below, spoiler alert:
>>>>>>>>>>>> ...
>>>>>>>>>>>>>
>>>>>>>>>>>>> ////
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> 17.4016863080244085 / 2.123 = 8.1967434328895
>>>>>>>>>>>>>
>>>>>>>>>>>>> 8.1967434328895 has the convergents:
>>>>>>>>>>>>>
>>>>>>>>>>>>> [8; 5 12 12 15]
>>>>>>>>>>>>>
>>>>>>>>>>>>> The plaintext is: hello
>>>>>>>>>>>>>
>>>>>>>>>>>>> ;^)
>>>>>>>>>>>>
>>>>>>>>>>>> Perhaps you didn't use arithmetic that was accurate enough?
>>>>>>>>>>> Shit. Must have. The funny thing is that wolfram gives the convergents
>>>>>>>>>>> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or
>>>>>>>>>>> something.
>>>>>>>>>>>
>>>>>>>>>>> https://www.wolframalpha.com/input/?i=8.1967434328895
>>>>>>>>>>>> The
>>>>>>>>>>>> convergents actually are [8; 5 12 12 14 1 282893 ...], which my
>>>>>>>>>>>> previously-mentioned continued-fractions-to-letters program showed as
>>>>>>>>>>>> `hellna`, which is not found in usual dictionaries.
>>>>>>>>>>>>
>>>>>>>>>>>> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...]
>>>>>>>>>> I am not sure how many digits in the decimal expansion of the target rational
>>>>>>>>>> you need to compare to the number of terms in the cf.
>>>>>>>>>> I way overdid it in my first post but it was a longer message that was encrypted but
>>>>>>>>>> probably could have used a much smaller in length rational to get the desired number of
>>>>>>>>>> of terms in the cf for the number to letter conversion.
>>>>>>>>>>
>>>>>>>>>> What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14..
>>>>>>>>>> and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13..
>>>>>>>>>> Think of it as using a slide rule where the private key
>>>>>>>>>> (a string of random letters along with each group number identifiers) is on the fixed portion of the
>>>>>>>>>> rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers.
>>>>>>>>>> These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter
>>>>>>>>>> with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted ---
>>>>>>>>>> A letter is only used once in the left to right scan like the word little the first T in little is used then the
>>>>>>>>>> scan continues by the decryptor for the second T because this private key string is made up of 49 alpha
>>>>>>>>>> characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd
>>>>>>>>>> count positions. Example below where this is easy to decrypt by just this simple method --
>>>>>>>>>>
>>>>>>>>>> ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ"
>>>>>>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan )
>>>>>>>>>> and scanning ----> again for the correct letter alignment to be cherry-picked from the private key.
>>>>>>>>>> This is giving the whole cipher idea away but the order of the characters in the private key can be drastically
>>>>>>>>>> changed along with the group identifiers then the public key would be useless to the person without the new private string.
>>>>>>>>>> In a completed scan (end of too the right ------>), there could be several stops for letter alignments.
>>>>>>>>>> I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done.
>>>>>>>>>> The above decryption of the public key above is easy if you follow the rules.
>>>>>>>>>> This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s
>>>>>>>>>> that worked great for encrypting and decrypting these numbers only 1-7 ciphers.
>>>>>>>>>> Just trying to transfer these thoughts into Python but not getting anywhere yet.
>>>>>>>>> Has anyone figured out, what I call, my seven square cipher yet?
>>>>>>>>> Or found any flaws in the concept?
>>>>>>>> Adding a level of security to any public key cipher of the above nature the group identifiers could be changed
>>>>>>>> to a different identifier position after each message sent.
>>>>>>>> This way no patterns of odd position numbers can be detected even though some
>>>>>>>> identifiers sometimes are used in succession breaking any pattern possible with future cipher messages.
>>>>>>>>
>>>>>>>> You may ask, why did I reveal the secrets to this cipher?
>>>>>>>> Okay, Just say I presented the public key ---
>>>>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7
>>>>>>>> Then said, solve this cipher, what is the hidden written message these numbers represent?
>>>>>>>> Duh, This is more powerful than even the German enigma machine.
>>>>>>>> This is because the public key encoded numeric message can be any length but the
>>>>>>>> private key is just 56 characters long. 1-7 group identifiers randomly located and the 49 Alpha characters.
>>>>>>>> In other words, I would die with this secret. ;-)
>>>>>>>
>>>>>>> That was stupid of me, The above cipher can be solved by anyone knowing the rules and the private
>>>>>>> key already revealed.
>>>>>>>
>>>>>> Also, if you are going to develop a cipher out of this, you need to make
>>>>>> sure that every encryption generates a radically different ciphertext,
>>>>>> even for the exact same plaintext. So encrypting the same plaintext
>>>>>> several times in a row would produce very different ciphertexts.
>>>>> Yes this is true, but because only 7 digits are used to pick an alpha character of 26 possibilities
>>>>> only the order of these 7 group identifiers is changed after each message
>>>>> The different combinations are 7! . A lot of messages (5048). Changed randomly. This way no letter connections
>>>>> other than a few out of 7 letters in a few groups after a few messages are sent but then complete contradictory results
>>>>> pointing to a letter involved with one particular identifier group of 7 letters.
>>>>> A bunch of test ciphertext would have to be processed to prove this point.
>>>>> The order right now of these group identifiers in this one example of the private key above is --- 3,5,1,6,2,7,4 and in
>>>>> odd positions in the private key alpha string --- 1,9,17,25,33,41,49 whose position never changes.
>>>>> 3,5,1,6,2,7,4 have 7! unique possibilities or (5040 possibilities) chosen from a random table of these possibilities.
>>>>> So only a 7 number change is necessary and once in a while change the random order (predetermined in a certain
>>>>> order of vowels and consonance strategically located in all the private string (groups of 7) should do the trick..
>>>>> Did you solve the cipher yet?
>>>>> I gave plenty of info by using the slide rule method and the actual private key and ciphertext associated with it.
>>>>
>>>> I just ran an actual algorithm and the ciphertext has 2 corrections you are supposed to solve against the private
>>>> alpha key.
>>>> When aligning an odd positioned group identifier from the public key it can only draw one letter from that group
>>>> in the private key string. This is because the left to right movement to align the identifier can't go back to the left
>>>> or stay in the same position on that identifier to choose the first but not the second letter within the same group.
>>>> So here is the corrected ciphertext with 4 corrections --
>>>> 5,7,1,2,6,1,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,2,2,4,2
>>>> It will be self-explanatory when you solve the cipher.
>>>>
>>> I am busy right now, but please post it over on sci.crypt.
>>>
>>> Using the same exact secret key, and encrypting the plaintext several
>>> times in a row should create different ciphertexts. Here is a crude
>>> example I made of my highly experimental fractal based encryption
>>> algorihtm. This funny fractal thing is radically different than my HMAC
>>> cipher. Anyway...
>>>
>>> Here are several ciphertexts that decrypt to the same exact plaintext
>>> using the default secret key using the following online program of mine:
>>>
>>> http://funwithfractals.atspace.cc/ffe
>>>
>>> The plaintext is: Hello World.
>>>
>>> 12 bytes
>>>
>>>
>>> ciphertext 0
>>> ______________________________
>>>
>>> 0.07464055294813914 0.21413369654338263
>>> 0.18726842930653814 0.15381457747419044
>>>
>>> 13 65 3C 20 32 43 F4 50 66 9C 27 7A
>>>
>>> ______________________________
>>>
>>>
>>> ciphertext 1
>>> ______________________________
>>>
>>> 0.10712703156460045 0.3825663517793289
>>> 0.3822450385558595 0.18493372431673
>>>
>>> DF 2D 40 B5 C4 69 C0 C8 E8 9E 4C 99
>>>
>>> ______________________________
>>>
>>>
>>> ciphertext 2
>>> ______________________________
>>>
>>> 0.4562359936711957 0.21850028449704323
>>> 0.3486656373192471 0.3596603216576378
>>>
>>> 4A 81 3D 5E 3F 26 F7 CF FD 15 83 15
>>>
>>> ______________________________
>>>
>>>
>>>
>>> To decrypt, copy-and-paste the text in between the lines into the Cipher
>>> Text box and click the Decrypt button. Better to use a desktop for the
>>> crude layout.
>>>
>>>
>>> This is using something called an IV. However, my HMAC cipher actually
>>> encrypts the random iv into the ciphertext itself. So, its not sent in
>>> the clear. Read all of:
>>>
>>> http://funwithfractals.atspace.cc/ct_cipher
>>>
>>> Also, read all of:
>>>
>>> https://groups.google.com/g/comp.lang.c/c/a53VxN8cwkY/m/WIxIwoK7DAAJ
>>>
>>>
>>> Actually, try clicking Encrypt multiple times and take a look at what
>>> happens to the ciphertext.
>> I put in --- thelittlebrowndogsquicklyjumpedoverthelazyfox
>> All the letters of the alphabet.
>> Some of the different renderings it creates is fantastic.
>> Genious.
>> I have not a clue of what you are doing but it is way over my head.
> 
> Can you enlarge the renderings?

Yes. The cipher render of the fractal described by the secret key and 
the random IV can be any size. I have it hardcoded at 128x128. So, in a 
strange sense, its almost a fractal explorer.

> That would be impressive to see what a simple sentence creates.
> I will have to take some time to study what you are doing.
> Thanks for this brilliant idea.
> 

[toc] | [prev] | [next] | [standalone]


#516419

Fromdjoyce099 <hlauk.h.bogart@gmail.com>
Date2021-04-02 15:01 -0700
Message-ID<e702bda0-2046-4376-9fdb-dacb9e8133ean@googlegroups.com>
In reply to#516328
On Friday, April 2, 2021 at 1:43:04 AM UTC-4, Chris M. Thomasson wrote:
> On 4/1/2021 9:55 PM, djoyce099 wrote: 
> > On Thursday, April 1, 2021 at 11:45:36 PM UTC-4, djoyce099 wrote: 
> >> On Thursday, April 1, 2021 at 7:58:28 PM UTC-4, Chris M. Thomasson wrote: 
> >>> On 4/1/2021 8:04 AM, djoyce099 wrote: 
> >>>> On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote: 
> >>>>> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote: 
> >>>>>> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote: 
> >>>>>>> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote: 
> >>>>>>>> On 3/31/2021 4:24 PM, James Waldby wrote: 
> >>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> >>>>>>>>>> On 3/31/2021 1:55 PM, James Waldby wrote: 
> >>>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> >>>>>>>>>>>> On 3/30/2021 11:36 AM, djoyce099 wrote: 
> >>>>>>>>>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote: 
> >>>>>>>>>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote: 
> >>>>>>>>>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote: 
> >>>>>>>>>>> ... 
> >>>>>>>>>>>>>>>> Now wrt your work, can you decrypt this? 
> >>>>>>>>>>>>>>>> 
> >>>>>>>>>>>>>>>> 17.4016863080244085 
> >>>>>>>>>>>>>>>> 
> >>>>>>>>>>>>>>>> It uses my simple idea of multiplying against a constant in the secret 
> >>>>>>>>>>>>>>>> key. You should post it there. 
> >>>>>>>>>>> ... 
> >>>>>>>>>>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are 
> >>>>>>>>>>>>>> different digits. 
> >>>>>>>>>>>>>> 
> >>>>>>>>>>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the 
> >>>>>>>>>>>>>> convergents of the original rational and use your initial mapping of 
> >>>>>>>>>>>>>> numbers to letters to decrypt the message. 
> >>>>>>>>>>> ... 
> >>>>>>>>>>>> 2. followed by three digits. So, its not 2.877 
> >>>>>>>>>>> 
> >>>>>>>>>>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x 
> >>>>>>>>>>> < y < z, the only word I see is `gab`, from divider 2.269. 
> >>>>>>>>>> 
> >>>>>>>>>> Its a number from 2.000 to 2.999. However, you need to divide 
> >>>>>>>>>> 17.4016863080244085 by it to get the original number that contains the 
> >>>>>>>>>> plaintext in its convergents. The answer is below, spoiler alert: 
> >>>>>>>>> ... 
> >>>>>>>>>> 
> >>>>>>>>>> //// 
> >>>>>>>>>> 
> >>>>>>>>>> 
> >>>>>>>>>> 
> >>>>>>>>>> 17.4016863080244085 / 2.123 = 8.1967434328895 
> >>>>>>>>>> 
> >>>>>>>>>> 8.1967434328895 has the convergents: 
> >>>>>>>>>> 
> >>>>>>>>>> [8; 5 12 12 15] 
> >>>>>>>>>> 
> >>>>>>>>>> The plaintext is: hello 
> >>>>>>>>>> 
> >>>>>>>>>> ;^) 
> >>>>>>>>> 
> >>>>>>>>> Perhaps you didn't use arithmetic that was accurate enough? 
> >>>>>>>> Shit. Must have. The funny thing is that wolfram gives the convergents 
> >>>>>>>> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or 
> >>>>>>>> something. 
> >>>>>>>> 
> >>>>>>>> https://www.wolframalpha.com/input/?i=8.1967434328895 
> >>>>>>>>> The 
> >>>>>>>>> convergents actually are [8; 5 12 12 14 1 282893 ...], which my 
> >>>>>>>>> previously-mentioned continued-fractions-to-letters program showed as 
> >>>>>>>>> `hellna`, which is not found in usual dictionaries. 
> >>>>>>>>> 
> >>>>>>>>> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...] 
> >>>>>>> I am not sure how many digits in the decimal expansion of the target rational 
> >>>>>>> you need to compare to the number of terms in the cf. 
> >>>>>>> I way overdid it in my first post but it was a longer message that was encrypted but 
> >>>>>>> probably could have used a much smaller in length rational to get the desired number of 
> >>>>>>> of terms in the cf for the number to letter conversion. 
> >>>>>>> 
> >>>>>>> What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14.. 
> >>>>>>> and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13.. 
> >>>>>>> Think of it as using a slide rule where the private key 
> >>>>>>> (a string of random letters along with each group number identifiers) is on the fixed portion of the 
> >>>>>>> rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers. 
> >>>>>>> These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter 
> >>>>>>> with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted --- 
> >>>>>>> A letter is only used once in the left to right scan like the word little the first T in little is used then the 
> >>>>>>> scan continues by the decryptor for the second T because this private key string is made up of 49 alpha 
> >>>>>>> characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd 
> >>>>>>> count positions. Example below where this is easy to decrypt by just this simple method -- 
> >>>>>>> 
> >>>>>>> ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ" 
> >>>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan ) 
> >>>>>>> and scanning ----> again for the correct letter alignment to be cherry-picked from the private key. 
> >>>>>>> This is giving the whole cipher idea away but the order of the characters in the private key can be drastically 
> >>>>>>> changed along with the group identifiers then the public key would be useless to the person without the new private string. 
> >>>>>>> In a completed scan (end of too the right ------>), there could be several stops for letter alignments. 
> >>>>>>> I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done. 
> >>>>>>> The above decryption of the public key above is easy if you follow the rules. 
> >>>>>>> This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s 
> >>>>>>> that worked great for encrypting and decrypting these numbers only 1-7 ciphers. 
> >>>>>>> Just trying to transfer these thoughts into Python but not getting anywhere yet. 
> >>>>>> Has anyone figured out, what I call, my seven square cipher yet? 
> >>>>>> Or found any flaws in the concept? 
> >>>>> Adding a level of security to any public key cipher of the above nature the group identifiers could be changed 
> >>>>> to a different identifier position after each message sent. 
> >>>>> This way no patterns of odd position numbers can be detected even though some 
> >>>>> identifiers sometimes are used in succession breaking any pattern possible with future cipher messages. 
> >>>>> 
> >>>>> You may ask, why did I reveal the secrets to this cipher? 
> >>>>> Okay, Just say I presented the public key --- 
> >>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 
> >>>>> Then said, solve this cipher, what is the hidden written message these numbers represent? 
> >>>>> Duh, This is more powerful than even the German enigma machine. 
> >>>>> This is because the public key encoded numeric message can be any length but the 
> >>>>> private key is just 56 characters long. 1-7 group identifiers randomly located and the 49 Alpha characters. 
> >>>>> In other words, I would die with this secret. ;-) 
> >>>> 
> >>>> That was stupid of me, The above cipher can be solved by anyone knowing the rules and the private 
> >>>> key already revealed. 
> >>>> 
> >>> Also, if you are going to develop a cipher out of this, you need to make 
> >>> sure that every encryption generates a radically different ciphertext, 
> >>> even for the exact same plaintext. So encrypting the same plaintext 
> >>> several times in a row would produce very different ciphertexts. 
> >> Yes this is true, but because only 7 digits are used to pick an alpha character of 26 possibilities 
> >> only the order of these 7 group identifiers is changed after each message 
> >> The different combinations are 7! . A lot of messages (5048). Changed randomly. This way no letter connections 
> >> other than a few out of 7 letters in a few groups after a few messages are sent but then complete contradictory results 
> >> pointing to a letter involved with one particular identifier group of 7 letters. 
> >> A bunch of test ciphertext would have to be processed to prove this point. 
> >> The order right now of these group identifiers in this one example of the private key above is --- 3,5,1,6,2,7,4 and in 
> >> odd positions in the private key alpha string --- 1,9,17,25,33,41,49 whose position never changes. 
> >> 3,5,1,6,2,7,4 have 7! unique possibilities or (5040 possibilities) chosen from a random table of these possibilities. 
> >> So only a 7 number change is necessary and once in a while change the random order (predetermined in a certain 
> >> order of vowels and consonance strategically located in all the private string (groups of 7) should do the trick.. 
> >> Did you solve the cipher yet? 
> >> I gave plenty of info by using the slide rule method and the actual private key and ciphertext associated with it. 
> > 
> > I just ran an actual algorithm and the ciphertext has 2 corrections you are supposed to solve against the private 
> > alpha key. 
> > When aligning an odd positioned group identifier from the public key it can only draw one letter from that group 
> > in the private key string. This is because the left to right movement to align the identifier can't go back to the left 
> > or stay in the same position on that identifier to choose the first but not the second letter within the same group. 
> > So here is the corrected ciphertext with 4 corrections -- 
> > 5,7,1,2,6,1,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,2,2,4,2 
> > It will be self-explanatory when you solve the cipher. 
> >
> I am busy right now, but please post it over on sci.crypt. 
> 
> Using the same exact secret key, and encrypting the plaintext several 
> times in a row should create different ciphertexts. Here is a crude 
> example I made of my highly experimental fractal based encryption 
> algorihtm. This funny fractal thing is radically different than my HMAC 
> cipher. Anyway... 
> 
> Here are several ciphertexts that decrypt to the same exact plaintext 
> using the default secret key using the following online program of mine: 
> 
> http://funwithfractals.atspace.cc/ffe 
> 
> The plaintext is: Hello World. 
> 
> 12 bytes 
> 
> 
> ciphertext 0 
> ______________________________ 
> 
> 0.07464055294813914 0.21413369654338263 
> 0.18726842930653814 0.15381457747419044 
> 
> 13 65 3C 20 32 43 F4 50 66 9C 27 7A 
> 
> ______________________________ 
> 
> 
> ciphertext 1 
> ______________________________ 
> 
> 0.10712703156460045 0.3825663517793289 
> 0.3822450385558595 0.18493372431673 
> 
> DF 2D 40 B5 C4 69 C0 C8 E8 9E 4C 99 
> 
> ______________________________ 
> 
> 
> ciphertext 2 
> ______________________________ 
> 
> 0.4562359936711957 0.21850028449704323 
> 0.3486656373192471 0.3596603216576378 
> 
> 4A 81 3D 5E 3F 26 F7 CF FD 15 83 15 
> 
> ______________________________ 
> 
> 
> 
> To decrypt, copy-and-paste the text in between the lines into the Cipher 
> Text box and click the Decrypt button. Better to use a desktop for the 
> crude layout. 
> 
> 
> This is using something called an IV. However, my HMAC cipher actually 
> encrypts the random iv into the ciphertext itself. So, its not sent in 
> the clear. Read all of: 
> 
> http://funwithfractals.atspace.cc/ct_cipher 
> 
> Also, read all of: 
> 
> https://groups.google.com/g/comp.lang.c/c/a53VxN8cwkY/m/WIxIwoK7DAAJ 
> 
> 
> Actually, try clicking Encrypt multiple times and take a look at what 
> happens to the ciphertext.

Chris,
It appears to create a few more encrypted 2 character codes than the actual number of alpha characters 
in the plaintext in a one-for-one matchup.
Interesting what is going on there.
Also, what are the number of mathematical possibilities of creating these 2 unique character codes of a mix
 of alpha-numeric or just alpha, or just numeric to give a final total of possibilities?
Is it 26! *10! ?  Probably not that big.
What do the fractional values represent in the top part of the lower window? 

[toc] | [prev] | [next] | [standalone]


#516421

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-02 15:18 -0700
Message-ID<s4858h$18tp$1@gioia.aioe.org>
In reply to#516419
On 4/2/2021 3:01 PM, djoyce099 wrote:
> On Friday, April 2, 2021 at 1:43:04 AM UTC-4, Chris M. Thomasson wrote:
>> On 4/1/2021 9:55 PM, djoyce099 wrote:
>>> On Thursday, April 1, 2021 at 11:45:36 PM UTC-4, djoyce099 wrote:
>>>> On Thursday, April 1, 2021 at 7:58:28 PM UTC-4, Chris M. Thomasson wrote:
>>>>> On 4/1/2021 8:04 AM, djoyce099 wrote:
>>>>>> On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote:
>>>>>>> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote:
>>>>>>>> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote:
>>>>>>>>> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. Thomasson wrote:
>>>>>>>>>> On 3/31/2021 4:24 PM, James Waldby wrote:
>>>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>>>>>>>>> On 3/31/2021 1:55 PM, James Waldby wrote:
>>>>>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>>>>>>>>>>> On 3/30/2021 11:36 AM, djoyce099 wrote:
>>>>>>>>>>>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. Thomasson wrote:
>>>>>>>>>>>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote:
>>>>>>>>>>>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, Chris M. Thomasson wrote:
>>>>>>>>>>>>> ...
>>>>>>>>>>>>>>>>>> Now wrt your work, can you decrypt this?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 17.4016863080244085
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It uses my simple idea of multiplying against a constant in the secret
>>>>>>>>>>>>>>>>>> key. You should post it there.
>>>>>>>>>>>>> ...
>>>>>>>>>>>>>>>> A massive hint. The secret constant consists of a 2.xyx. x y and z are
>>>>>>>>>>>>>>>> different digits.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 17.4016863080244085 / 2.xyz = the original rational. Take the
>>>>>>>>>>>>>>>> convergents of the original rational and use your initial mapping of
>>>>>>>>>>>>>>>> numbers to letters to decrypt the message.
>>>>>>>>>>>>> ...
>>>>>>>>>>>>>> 2. followed by three digits. So, its not 2.877
>>>>>>>>>>>>>
>>>>>>>>>>>>> Testing the values from 2.000 to 2.999, and limiting to 2.xyz where x
>>>>>>>>>>>>> < y < z, the only word I see is `gab`, from divider 2.269.
>>>>>>>>>>>>
>>>>>>>>>>>> Its a number from 2.000 to 2.999. However, you need to divide
>>>>>>>>>>>> 17.4016863080244085 by it to get the original number that contains the
>>>>>>>>>>>> plaintext in its convergents. The answer is below, spoiler alert:
>>>>>>>>>>> ...
>>>>>>>>>>>>
>>>>>>>>>>>> ////
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> 17.4016863080244085 / 2.123 = 8.1967434328895
>>>>>>>>>>>>
>>>>>>>>>>>> 8.1967434328895 has the convergents:
>>>>>>>>>>>>
>>>>>>>>>>>> [8; 5 12 12 15]
>>>>>>>>>>>>
>>>>>>>>>>>> The plaintext is: hello
>>>>>>>>>>>>
>>>>>>>>>>>> ;^)
>>>>>>>>>>>
>>>>>>>>>>> Perhaps you didn't use arithmetic that was accurate enough?
>>>>>>>>>> Shit. Must have. The funny thing is that wolfram gives the convergents
>>>>>>>>>> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be rounding or
>>>>>>>>>> something.
>>>>>>>>>>
>>>>>>>>>> https://www.wolframalpha.com/input/?i=8.1967434328895
>>>>>>>>>>> The
>>>>>>>>>>> convergents actually are [8; 5 12 12 14 1 282893 ...], which my
>>>>>>>>>>> previously-mentioned continued-fractions-to-letters program showed as
>>>>>>>>>>> `hellna`, which is not found in usual dictionaries.
>>>>>>>>>>>
>>>>>>>>>>> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 20614211 ...]
>>>>>>>>> I am not sure how many digits in the decimal expansion of the target rational
>>>>>>>>> you need to compare to the number of terms in the cf.
>>>>>>>>> I way overdid it in my first post but it was a longer message that was encrypted but
>>>>>>>>> probably could have used a much smaller in length rational to get the desired number of
>>>>>>>>> of terms in the cf for the number to letter conversion.
>>>>>>>>>
>>>>>>>>> What about the new cipher I propose using only numbers 1-7 in the even positions -- 2,4,6,8,10,12,14..
>>>>>>>>> and group number identifiers 1-7 in the odd positions -- 1,3,5,7,9,11,13..
>>>>>>>>> Think of it as using a slide rule where the private key
>>>>>>>>> (a string of random letters along with each group number identifiers) is on the fixed portion of the
>>>>>>>>> rule and the slider portion has the cipher encrypted message of just the numbers 1-7 and the 7 group identifiers.
>>>>>>>>> These two strings are placed side by side and sliding the ciphertext from left to right and aligning each letter
>>>>>>>>> with the encrypted numbers of the sliding portion of the rule. The examples I have previously posted ---
>>>>>>>>> A letter is only used once in the left to right scan like the word little the first T in little is used then the
>>>>>>>>> scan continues by the decryptor for the second T because this private key string is made up of 49 alpha
>>>>>>>>> characters = 26*2 minus the second XYZ = 49 Alpha characters and 1-7 group identifiers placed in the odd
>>>>>>>>> count positions. Example below where this is easy to decrypt by just this simple method --
>>>>>>>>>
>>>>>>>>> ----------------------------------------------------------------------------------------- Fixed private key--------------------------------------------------------- ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ"
>>>>>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > Sliding cipher for the right letter alignment --- a public key sent to be decrypted. moving --> then when reaching the end of the fixed private key the cipher is brought back <--- (no scan )
>>>>>>>>> and scanning ----> again for the correct letter alignment to be cherry-picked from the private key.
>>>>>>>>> This is giving the whole cipher idea away but the order of the characters in the private key can be drastically
>>>>>>>>> changed along with the group identifiers then the public key would be useless to the person without the new private string.
>>>>>>>>> In a completed scan (end of too the right ------>), there could be several stops for letter alignments.
>>>>>>>>> I am just using this analogy of sliding but the right parsing of strings in both algorithms would get the job done.
>>>>>>>>> The above decryption of the public key above is easy if you follow the rules.
>>>>>>>>> This is just what I can remember from these old algorithms I produced in basic on my commodore 64 back in the 80s
>>>>>>>>> that worked great for encrypting and decrypting these numbers only 1-7 ciphers.
>>>>>>>>> Just trying to transfer these thoughts into Python but not getting anywhere yet.
>>>>>>>> Has anyone figured out, what I call, my seven square cipher yet?
>>>>>>>> Or found any flaws in the concept?
>>>>>>> Adding a level of security to any public key cipher of the above nature the group identifiers could be changed
>>>>>>> to a different identifier position after each message sent.
>>>>>>> This way no patterns of odd position numbers can be detected even though some
>>>>>>> identifiers sometimes are used in succession breaking any pattern possible with future cipher messages.
>>>>>>>
>>>>>>> You may ask, why did I reveal the secrets to this cipher?
>>>>>>> Okay, Just say I presented the public key ---
>>>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7
>>>>>>> Then said, solve this cipher, what is the hidden written message these numbers represent?
>>>>>>> Duh, This is more powerful than even the German enigma machine.
>>>>>>> This is because the public key encoded numeric message can be any length but the
>>>>>>> private key is just 56 characters long. 1-7 group identifiers randomly located and the 49 Alpha characters.
>>>>>>> In other words, I would die with this secret. ;-)
>>>>>>
>>>>>> That was stupid of me, The above cipher can be solved by anyone knowing the rules and the private
>>>>>> key already revealed.
>>>>>>
>>>>> Also, if you are going to develop a cipher out of this, you need to make
>>>>> sure that every encryption generates a radically different ciphertext,
>>>>> even for the exact same plaintext. So encrypting the same plaintext
>>>>> several times in a row would produce very different ciphertexts.
>>>> Yes this is true, but because only 7 digits are used to pick an alpha character of 26 possibilities
>>>> only the order of these 7 group identifiers is changed after each message
>>>> The different combinations are 7! . A lot of messages (5048). Changed randomly. This way no letter connections
>>>> other than a few out of 7 letters in a few groups after a few messages are sent but then complete contradictory results
>>>> pointing to a letter involved with one particular identifier group of 7 letters.
>>>> A bunch of test ciphertext would have to be processed to prove this point.
>>>> The order right now of these group identifiers in this one example of the private key above is --- 3,5,1,6,2,7,4 and in
>>>> odd positions in the private key alpha string --- 1,9,17,25,33,41,49 whose position never changes.
>>>> 3,5,1,6,2,7,4 have 7! unique possibilities or (5040 possibilities) chosen from a random table of these possibilities.
>>>> So only a 7 number change is necessary and once in a while change the random order (predetermined in a certain
>>>> order of vowels and consonance strategically located in all the private string (groups of 7) should do the trick..
>>>> Did you solve the cipher yet?
>>>> I gave plenty of info by using the slide rule method and the actual private key and ciphertext associated with it.
>>>
>>> I just ran an actual algorithm and the ciphertext has 2 corrections you are supposed to solve against the private
>>> alpha key.
>>> When aligning an odd positioned group identifier from the public key it can only draw one letter from that group
>>> in the private key string. This is because the left to right movement to align the identifier can't go back to the left
>>> or stay in the same position on that identifier to choose the first but not the second letter within the same group.
>>> So here is the corrected ciphertext with 4 corrections --
>>> 5,7,1,2,6,1,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,2,2,4,2
>>> It will be self-explanatory when you solve the cipher.
>>>
>> I am busy right now, but please post it over on sci.crypt.
>>
>> Using the same exact secret key, and encrypting the plaintext several
>> times in a row should create different ciphertexts. Here is a crude
>> example I made of my highly experimental fractal based encryption
>> algorihtm. This funny fractal thing is radically different than my HMAC
>> cipher. Anyway...
>>
>> Here are several ciphertexts that decrypt to the same exact plaintext
>> using the default secret key using the following online program of mine:
>>
>> http://funwithfractals.atspace.cc/ffe
>>
>> The plaintext is: Hello World.
>>
>> 12 bytes
>>
>>
>> ciphertext 0
>> ______________________________
>>
>> 0.07464055294813914 0.21413369654338263
>> 0.18726842930653814 0.15381457747419044
>>
>> 13 65 3C 20 32 43 F4 50 66 9C 27 7A
>>
>> ______________________________
>>
>>
>> ciphertext 1
>> ______________________________
>>
>> 0.10712703156460045 0.3825663517793289
>> 0.3822450385558595 0.18493372431673
>>
>> DF 2D 40 B5 C4 69 C0 C8 E8 9E 4C 99
>>
>> ______________________________
>>
>>
>> ciphertext 2
>> ______________________________
>>
>> 0.4562359936711957 0.21850028449704323
>> 0.3486656373192471 0.3596603216576378
>>
>> 4A 81 3D 5E 3F 26 F7 CF FD 15 83 15
>>
>> ______________________________
>>
>>
>>
>> To decrypt, copy-and-paste the text in between the lines into the Cipher
>> Text box and click the Decrypt button. Better to use a desktop for the
>> crude layout.
>>
>>
>> This is using something called an IV. However, my HMAC cipher actually
>> encrypts the random iv into the ciphertext itself. So, its not sent in
>> the clear. Read all of:
>>
>> http://funwithfractals.atspace.cc/ct_cipher
>>
>> Also, read all of:
>>
>> https://groups.google.com/g/comp.lang.c/c/a53VxN8cwkY/m/WIxIwoK7DAAJ
>>
>>
>> Actually, try clicking Encrypt multiple times and take a look at what
>> happens to the ciphertext.
> 
> Chris,
> It appears to create a few more encrypted 2 character codes than the actual number of alpha characters
> in the plaintext in a one-for-one matchup.

My highly experimental FFE cipher creates a ciphertext hexbyte for each 
plaintext character. Can you show me an example plaintext where it 
creates more? This is different than my HMAC cipher that can extend the 
ciphertext and make it larger than the plaintext via using TRNG random 
bytes in the plaintext before encrypting. read all: 
http://funwithfractals.atspace.cc/ct_cipher

Now, back to my FFE. So, encrypting Hello using the default key can be:
_______________________
0.12934470968540027 0.025161836871791087
0.03337929216249355 0.11671759502753765

FF 19 E6 62 D5
_______________________

5 Hexbytes FF 19 E6 62 D5.

If you can give me a plaintext that creates more than hexbytes than the 
number of characters in the plaintext, please show me!

> Interesting what is going on there.
> Also, what are the number of mathematical possibilities of creating these 2 unique character codes of a mix
>   of alpha-numeric or just alpha, or just numeric to give a final total of possibilities?
> Is it 26! *10! ?  Probably not that big.

I am not sure. It depends on how many different secret keys one can make 
and how many possibilities of getting the same exact random IV.


> What do the fractional values represent in the top part of the lower window?

Its part of a view into the fractal generated by the key. To get the 
real view, the algorihtm combines the fractional values with the secret 
key. So, basically it acts like a random IV:

https://en.wikipedia.org/wiki/Initialization_vector

Since its not using a TRNG to generate random numbers, just JavaScripts 
random() it most likely has a period, as in a PRNG. My HMAC requires a 
TRNG to generate its random data.

[toc] | [prev] | [next] | [standalone]


#516423

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-02 15:32 -0700
Message-ID<s4861m$1ir4$1@gioia.aioe.org>
In reply to#516421
On 4/2/2021 3:18 PM, Chris M. Thomasson wrote:
> On 4/2/2021 3:01 PM, djoyce099 wrote:
>> On Friday, April 2, 2021 at 1:43:04 AM UTC-4, Chris M. Thomasson wrote:
>>> On 4/1/2021 9:55 PM, djoyce099 wrote:
>>>> On Thursday, April 1, 2021 at 11:45:36 PM UTC-4, djoyce099 wrote:
>>>>> On Thursday, April 1, 2021 at 7:58:28 PM UTC-4, Chris M. Thomasson 
>>>>> wrote:
>>>>>> On 4/1/2021 8:04 AM, djoyce099 wrote:
>>>>>>> On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote:
>>>>>>>> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote:
>>>>>>>>> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote:
>>>>>>>>>> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. 
>>>>>>>>>> Thomasson wrote:
>>>>>>>>>>> On 3/31/2021 4:24 PM, James Waldby wrote:
>>>>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>>>>>>>>>> On 3/31/2021 1:55 PM, James Waldby wrote:
>>>>>>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>>>>>>>>>>>> On 3/30/2021 11:36 AM, djoyce099 wrote:
>>>>>>>>>>>>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. 
>>>>>>>>>>>>>>>> Thomasson wrote:
>>>>>>>>>>>>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote:
>>>>>>>>>>>>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, 
>>>>>>>>>>>>>>>>>> Chris M. Thomasson wrote:
>>>>>>>>>>>>>> ...
>>>>>>>>>>>>>>>>>>> Now wrt your work, can you decrypt this?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 17.4016863080244085
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It uses my simple idea of multiplying against a 
>>>>>>>>>>>>>>>>>>> constant in the secret
>>>>>>>>>>>>>>>>>>> key. You should post it there.
>>>>>>>>>>>>>> ...
>>>>>>>>>>>>>>>>> A massive hint. The secret constant consists of a 
>>>>>>>>>>>>>>>>> 2.xyx. x y and z are
>>>>>>>>>>>>>>>>> different digits.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 17.4016863080244085 / 2.xyz = the original rational. 
>>>>>>>>>>>>>>>>> Take the
>>>>>>>>>>>>>>>>> convergents of the original rational and use your 
>>>>>>>>>>>>>>>>> initial mapping of
>>>>>>>>>>>>>>>>> numbers to letters to decrypt the message.
>>>>>>>>>>>>>> ...
>>>>>>>>>>>>>>> 2. followed by three digits. So, its not 2.877
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Testing the values from 2.000 to 2.999, and limiting to 
>>>>>>>>>>>>>> 2.xyz where x
>>>>>>>>>>>>>> < y < z, the only word I see is `gab`, from divider 2.269.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Its a number from 2.000 to 2.999. However, you need to divide
>>>>>>>>>>>>> 17.4016863080244085 by it to get the original number that 
>>>>>>>>>>>>> contains the
>>>>>>>>>>>>> plaintext in its convergents. The answer is below, spoiler 
>>>>>>>>>>>>> alert:
>>>>>>>>>>>> ...
>>>>>>>>>>>>>
>>>>>>>>>>>>> ////
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> 17.4016863080244085 / 2.123 = 8.1967434328895
>>>>>>>>>>>>>
>>>>>>>>>>>>> 8.1967434328895 has the convergents:
>>>>>>>>>>>>>
>>>>>>>>>>>>> [8; 5 12 12 15]
>>>>>>>>>>>>>
>>>>>>>>>>>>> The plaintext is: hello
>>>>>>>>>>>>>
>>>>>>>>>>>>> ;^)
>>>>>>>>>>>>
>>>>>>>>>>>> Perhaps you didn't use arithmetic that was accurate enough?
>>>>>>>>>>> Shit. Must have. The funny thing is that wolfram gives the 
>>>>>>>>>>> convergents
>>>>>>>>>>> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be 
>>>>>>>>>>> rounding or
>>>>>>>>>>> something.
>>>>>>>>>>>
>>>>>>>>>>> https://www.wolframalpha.com/input/?i=8.1967434328895
>>>>>>>>>>>> The
>>>>>>>>>>>> convergents actually are [8; 5 12 12 14 1 282893 ...], which my
>>>>>>>>>>>> previously-mentioned continued-fractions-to-letters program 
>>>>>>>>>>>> showed as
>>>>>>>>>>>> `hellna`, which is not found in usual dictionaries.
>>>>>>>>>>>>
>>>>>>>>>>>> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 
>>>>>>>>>>>> 20614211 ...]
>>>>>>>>>> I am not sure how many digits in the decimal expansion of the 
>>>>>>>>>> target rational
>>>>>>>>>> you need to compare to the number of terms in the cf.
>>>>>>>>>> I way overdid it in my first post but it was a longer message 
>>>>>>>>>> that was encrypted but
>>>>>>>>>> probably could have used a much smaller in length rational to 
>>>>>>>>>> get the desired number of
>>>>>>>>>> of terms in the cf for the number to letter conversion.
>>>>>>>>>>
>>>>>>>>>> What about the new cipher I propose using only numbers 1-7 in 
>>>>>>>>>> the even positions -- 2,4,6,8,10,12,14..
>>>>>>>>>> and group number identifiers 1-7 in the odd positions -- 
>>>>>>>>>> 1,3,5,7,9,11,13..
>>>>>>>>>> Think of it as using a slide rule where the private key
>>>>>>>>>> (a string of random letters along with each group number 
>>>>>>>>>> identifiers) is on the fixed portion of the
>>>>>>>>>> rule and the slider portion has the cipher encrypted message 
>>>>>>>>>> of just the numbers 1-7 and the 7 group identifiers.
>>>>>>>>>> These two strings are placed side by side and sliding the 
>>>>>>>>>> ciphertext from left to right and aligning each letter
>>>>>>>>>> with the encrypted numbers of the sliding portion of the rule. 
>>>>>>>>>> The examples I have previously posted ---
>>>>>>>>>> A letter is only used once in the left to right scan like the 
>>>>>>>>>> word little the first T in little is used then the
>>>>>>>>>> scan continues by the decryptor for the second T because this 
>>>>>>>>>> private key string is made up of 49 alpha
>>>>>>>>>> characters = 26*2 minus the second XYZ = 49 Alpha characters 
>>>>>>>>>> and 1-7 group identifiers placed in the odd
>>>>>>>>>> count positions. Example below where this is easy to decrypt 
>>>>>>>>>> by just this simple method --
>>>>>>>>>>
>>>>>>>>>> ----------------------------------------------------------------------------------------- 
>>>>>>>>>> Fixed private 
>>>>>>>>>> key--------------------------------------------------------- 
>>>>>>>>>> ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ" 
>>>>>>>>>>
>>>>>>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > 
>>>>>>>>>> Sliding cipher for the right letter alignment --- a public key 
>>>>>>>>>> sent to be decrypted. moving --> then when reaching the end of 
>>>>>>>>>> the fixed private key the cipher is brought back <--- (no scan )
>>>>>>>>>> and scanning ----> again for the correct letter alignment to 
>>>>>>>>>> be cherry-picked from the private key.
>>>>>>>>>> This is giving the whole cipher idea away but the order of the 
>>>>>>>>>> characters in the private key can be drastically
>>>>>>>>>> changed along with the group identifiers then the public key 
>>>>>>>>>> would be useless to the person without the new private string.
>>>>>>>>>> In a completed scan (end of too the right ------>), there 
>>>>>>>>>> could be several stops for letter alignments.
>>>>>>>>>> I am just using this analogy of sliding but the right parsing 
>>>>>>>>>> of strings in both algorithms would get the job done.
>>>>>>>>>> The above decryption of the public key above is easy if you 
>>>>>>>>>> follow the rules.
>>>>>>>>>> This is just what I can remember from these old algorithms I 
>>>>>>>>>> produced in basic on my commodore 64 back in the 80s
>>>>>>>>>> that worked great for encrypting and decrypting these numbers 
>>>>>>>>>> only 1-7 ciphers.
>>>>>>>>>> Just trying to transfer these thoughts into Python but not 
>>>>>>>>>> getting anywhere yet.
>>>>>>>>> Has anyone figured out, what I call, my seven square cipher yet?
>>>>>>>>> Or found any flaws in the concept?
>>>>>>>> Adding a level of security to any public key cipher of the above 
>>>>>>>> nature the group identifiers could be changed
>>>>>>>> to a different identifier position after each message sent.
>>>>>>>> This way no patterns of odd position numbers can be detected 
>>>>>>>> even though some
>>>>>>>> identifiers sometimes are used in succession breaking any 
>>>>>>>> pattern possible with future cipher messages.
>>>>>>>>
>>>>>>>> You may ask, why did I reveal the secrets to this cipher?
>>>>>>>> Okay, Just say I presented the public key ---
>>>>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7
>>>>>>>> Then said, solve this cipher, what is the hidden written message 
>>>>>>>> these numbers represent?
>>>>>>>> Duh, This is more powerful than even the German enigma machine.
>>>>>>>> This is because the public key encoded numeric message can be 
>>>>>>>> any length but the
>>>>>>>> private key is just 56 characters long. 1-7 group identifiers 
>>>>>>>> randomly located and the 49 Alpha characters.
>>>>>>>> In other words, I would die with this secret. ;-)
>>>>>>>
>>>>>>> That was stupid of me, The above cipher can be solved by anyone 
>>>>>>> knowing the rules and the private
>>>>>>> key already revealed.
>>>>>>>
>>>>>> Also, if you are going to develop a cipher out of this, you need 
>>>>>> to make
>>>>>> sure that every encryption generates a radically different 
>>>>>> ciphertext,
>>>>>> even for the exact same plaintext. So encrypting the same plaintext
>>>>>> several times in a row would produce very different ciphertexts.
>>>>> Yes this is true, but because only 7 digits are used to pick an 
>>>>> alpha character of 26 possibilities
>>>>> only the order of these 7 group identifiers is changed after each 
>>>>> message
>>>>> The different combinations are 7! . A lot of messages (5048). 
>>>>> Changed randomly. This way no letter connections
>>>>> other than a few out of 7 letters in a few groups after a few 
>>>>> messages are sent but then complete contradictory results
>>>>> pointing to a letter involved with one particular identifier group 
>>>>> of 7 letters.
>>>>> A bunch of test ciphertext would have to be processed to prove this 
>>>>> point.
>>>>> The order right now of these group identifiers in this one example 
>>>>> of the private key above is --- 3,5,1,6,2,7,4 and in
>>>>> odd positions in the private key alpha string --- 
>>>>> 1,9,17,25,33,41,49 whose position never changes.
>>>>> 3,5,1,6,2,7,4 have 7! unique possibilities or (5040 possibilities) 
>>>>> chosen from a random table of these possibilities.
>>>>> So only a 7 number change is necessary and once in a while change 
>>>>> the random order (predetermined in a certain
>>>>> order of vowels and consonance strategically located in all the 
>>>>> private string (groups of 7) should do the trick..
>>>>> Did you solve the cipher yet?
>>>>> I gave plenty of info by using the slide rule method and the actual 
>>>>> private key and ciphertext associated with it.
>>>>
>>>> I just ran an actual algorithm and the ciphertext has 2 corrections 
>>>> you are supposed to solve against the private
>>>> alpha key.
>>>> When aligning an odd positioned group identifier from the public key 
>>>> it can only draw one letter from that group
>>>> in the private key string. This is because the left to right 
>>>> movement to align the identifier can't go back to the left
>>>> or stay in the same position on that identifier to choose the first 
>>>> but not the second letter within the same group.
>>>> So here is the corrected ciphertext with 4 corrections --
>>>> 5,7,1,2,6,1,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,2,2,4,2
>>>> It will be self-explanatory when you solve the cipher.
>>>>
>>> I am busy right now, but please post it over on sci.crypt.
>>>
>>> Using the same exact secret key, and encrypting the plaintext several
>>> times in a row should create different ciphertexts. Here is a crude
>>> example I made of my highly experimental fractal based encryption
>>> algorihtm. This funny fractal thing is radically different than my HMAC
>>> cipher. Anyway...
>>>
>>> Here are several ciphertexts that decrypt to the same exact plaintext
>>> using the default secret key using the following online program of mine:
>>>
>>> http://funwithfractals.atspace.cc/ffe
>>>
>>> The plaintext is: Hello World.
>>>
>>> 12 bytes
>>>
>>>
>>> ciphertext 0
>>> ______________________________
>>>
>>> 0.07464055294813914 0.21413369654338263
>>> 0.18726842930653814 0.15381457747419044
>>>
>>> 13 65 3C 20 32 43 F4 50 66 9C 27 7A
>>>
>>> ______________________________
>>>
>>>
>>> ciphertext 1
>>> ______________________________
>>>
>>> 0.10712703156460045 0.3825663517793289
>>> 0.3822450385558595 0.18493372431673
>>>
>>> DF 2D 40 B5 C4 69 C0 C8 E8 9E 4C 99
>>>
>>> ______________________________
>>>
>>>
>>> ciphertext 2
>>> ______________________________
>>>
>>> 0.4562359936711957 0.21850028449704323
>>> 0.3486656373192471 0.3596603216576378
>>>
>>> 4A 81 3D 5E 3F 26 F7 CF FD 15 83 15
>>>
>>> ______________________________
>>>
>>>
>>>
>>> To decrypt, copy-and-paste the text in between the lines into the Cipher
>>> Text box and click the Decrypt button. Better to use a desktop for the
>>> crude layout.
>>>
>>>
>>> This is using something called an IV. However, my HMAC cipher actually
>>> encrypts the random iv into the ciphertext itself. So, its not sent in
>>> the clear. Read all of:
>>>
>>> http://funwithfractals.atspace.cc/ct_cipher
>>>
>>> Also, read all of:
>>>
>>> https://groups.google.com/g/comp.lang.c/c/a53VxN8cwkY/m/WIxIwoK7DAAJ
>>>
>>>
>>> Actually, try clicking Encrypt multiple times and take a look at what
>>> happens to the ciphertext.
>>
>> Chris,
>> It appears to create a few more encrypted 2 character codes than the 
>> actual number of alpha characters
>> in the plaintext in a one-for-one matchup.
> 
> My highly experimental FFE cipher creates a ciphertext hexbyte for each 
> plaintext character. Can you show me an example plaintext where it 
> creates more? This is different than my HMAC cipher that can extend the 
> ciphertext and make it larger than the plaintext via using TRNG random 
> bytes in the plaintext before encrypting. read all: 
> http://funwithfractals.atspace.cc/ct_cipher
> 
> Now, back to my FFE. So, encrypting Hello using the default key can be:
> _______________________
> 0.12934470968540027 0.025161836871791087
> 0.03337929216249355 0.11671759502753765
> 
> FF 19 E6 62 D5
> _______________________
> 
> 5 Hexbytes FF 19 E6 62 D5.
> 
> If you can give me a plaintext that creates more than hexbytes than the 
> number of characters in the plaintext, please show me!
> 
>> Interesting what is going on there.
>> Also, what are the number of mathematical possibilities of creating 
>> these 2 unique character codes of a mix
>>   of alpha-numeric or just alpha, or just numeric to give a final 
>> total of possibilities?
>> Is it 26! *10! ?  Probably not that big.
> 
> I am not sure. It depends on how many different secret keys one can make 
> and how many possibilities of getting the same exact random IV.[...]

Then again, using the example above with Hello at hexbytes: FF 19 E6 62 
D5, it would be 5 16-bit numbers. So, the probability would be the 
chances of rolling 5 16 sided die and getting a result X. Okay, now how 
many times do we need to roll to get X again? Each roll would be a click 
of the Encrypt button for the same plaintext and secret key. Yes, the 
secret key comes into play. Because FF 19 E6 62 D5 does not work with 
another secret key that was not used to create it.

[toc] | [prev] | [next] | [standalone]


#516463

Fromdjoyce099 <hlauk.h.bogart@gmail.com>
Date2021-04-03 05:44 -0700
Message-ID<798c56f3-0698-415a-8393-9b9ef1f4314dn@googlegroups.com>
In reply to#516423
On Friday, April 2, 2021 at 6:32:33 PM UTC-4, Chris M. Thomasson wrote:
> On 4/2/2021 3:18 PM, Chris M. Thomasson wrote: 
> > On 4/2/2021 3:01 PM, djoyce099 wrote: 
> >> On Friday, April 2, 2021 at 1:43:04 AM UTC-4, Chris M. Thomasson wrote: 
> >>> On 4/1/2021 9:55 PM, djoyce099 wrote: 
> >>>> On Thursday, April 1, 2021 at 11:45:36 PM UTC-4, djoyce099 wrote: 
> >>>>> On Thursday, April 1, 2021 at 7:58:28 PM UTC-4, Chris M. Thomasson 
> >>>>> wrote: 
> >>>>>> On 4/1/2021 8:04 AM, djoyce099 wrote: 
> >>>>>>> On Thursday, April 1, 2021 at 10:39:24 AM UTC-4, djoyce099 wrote: 
> >>>>>>>> On Thursday, April 1, 2021 at 9:21:54 AM UTC-4, djoyce099 wrote: 
> >>>>>>>>> On Wednesday, March 31, 2021 at 9:32:45 PM UTC-4, djoyce099 wrote: 
> >>>>>>>>>> On Wednesday, March 31, 2021 at 7:49:23 PM UTC-4, Chris M. 
> >>>>>>>>>> Thomasson wrote: 
> >>>>>>>>>>> On 3/31/2021 4:24 PM, James Waldby wrote: 
> >>>>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> >>>>>>>>>>>>> On 3/31/2021 1:55 PM, James Waldby wrote: 
> >>>>>>>>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote: 
> >>>>>>>>>>>>>>> On 3/30/2021 11:36 AM, djoyce099 wrote: 
> >>>>>>>>>>>>>>>> On Monday, March 29, 2021 at 7:48:36 PM UTC-4, Chris M. 
> >>>>>>>>>>>>>>>> Thomasson wrote: 
> >>>>>>>>>>>>>>>>> On 3/24/2021 12:43 PM, djoyce099 wrote: 
> >>>>>>>>>>>>>>>>>> On Wednesday, March 24, 2021 at 1:14:53 AM UTC-4, 
> >>>>>>>>>>>>>>>>>> Chris M. Thomasson wrote: 
> >>>>>>>>>>>>>> ... 
> >>>>>>>>>>>>>>>>>>> Now wrt your work, can you decrypt this? 
> >>>>>>>>>>>>>>>>>>> 
> >>>>>>>>>>>>>>>>>>> 17.4016863080244085 
> >>>>>>>>>>>>>>>>>>> 
> >>>>>>>>>>>>>>>>>>> It uses my simple idea of multiplying against a 
> >>>>>>>>>>>>>>>>>>> constant in the secret 
> >>>>>>>>>>>>>>>>>>> key. You should post it there. 
> >>>>>>>>>>>>>> ... 
> >>>>>>>>>>>>>>>>> A massive hint. The secret constant consists of a 
> >>>>>>>>>>>>>>>>> 2.xyx. x y and z are 
> >>>>>>>>>>>>>>>>> different digits. 
> >>>>>>>>>>>>>>>>> 
> >>>>>>>>>>>>>>>>> 17.4016863080244085 / 2.xyz = the original rational. 
> >>>>>>>>>>>>>>>>> Take the 
> >>>>>>>>>>>>>>>>> convergents of the original rational and use your 
> >>>>>>>>>>>>>>>>> initial mapping of 
> >>>>>>>>>>>>>>>>> numbers to letters to decrypt the message. 
> >>>>>>>>>>>>>> ... 
> >>>>>>>>>>>>>>> 2. followed by three digits. So, its not 2.877 
> >>>>>>>>>>>>>> 
> >>>>>>>>>>>>>> Testing the values from 2.000 to 2.999, and limiting to 
> >>>>>>>>>>>>>> 2.xyz where x 
> >>>>>>>>>>>>>> < y < z, the only word I see is `gab`, from divider 2.269. 
> >>>>>>>>>>>>> 
> >>>>>>>>>>>>> Its a number from 2.000 to 2.999. However, you need to divide 
> >>>>>>>>>>>>> 17.4016863080244085 by it to get the original number that 
> >>>>>>>>>>>>> contains the 
> >>>>>>>>>>>>> plaintext in its convergents. The answer is below, spoiler 
> >>>>>>>>>>>>> alert: 
> >>>>>>>>>>>> ... 
> >>>>>>>>>>>>> 
> >>>>>>>>>>>>> //// 
> >>>>>>>>>>>>> 
> >>>>>>>>>>>>> 
> >>>>>>>>>>>>> 
> >>>>>>>>>>>>> 17.4016863080244085 / 2.123 = 8.1967434328895 
> >>>>>>>>>>>>> 
> >>>>>>>>>>>>> 8.1967434328895 has the convergents: 
> >>>>>>>>>>>>> 
> >>>>>>>>>>>>> [8; 5 12 12 15] 
> >>>>>>>>>>>>> 
> >>>>>>>>>>>>> The plaintext is: hello 
> >>>>>>>>>>>>> 
> >>>>>>>>>>>>> ;^) 
> >>>>>>>>>>>> 
> >>>>>>>>>>>> Perhaps you didn't use arithmetic that was accurate enough? 
> >>>>>>>>>>> Shit. Must have. The funny thing is that wolfram gives the 
> >>>>>>>>>>> convergents 
> >>>>>>>>>>> [8; 5 12 12 15] for 8.1967434328895. Strange, it must be 
> >>>>>>>>>>> rounding or 
> >>>>>>>>>>> something. 
> >>>>>>>>>>> 
> >>>>>>>>>>> https://www.wolframalpha.com/input/?i=8.1967434328895 
> >>>>>>>>>>>> The 
> >>>>>>>>>>>> convergents actually are [8; 5 12 12 14 1 282893 ...], which my 
> >>>>>>>>>>>> previously-mentioned continued-fractions-to-letters program 
> >>>>>>>>>>>> showed as 
> >>>>>>>>>>>> `hellna`, which is not found in usual dictionaries. 
> >>>>>>>>>>>> 
> >>>>>>>>>>>> On the other hand, 8.196743432889529 has c.f. [8; 5 12 12 15 
> >>>>>>>>>>>> 20614211 ...] 
> >>>>>>>>>> I am not sure how many digits in the decimal expansion of the 
> >>>>>>>>>> target rational 
> >>>>>>>>>> you need to compare to the number of terms in the cf. 
> >>>>>>>>>> I way overdid it in my first post but it was a longer message 
> >>>>>>>>>> that was encrypted but 
> >>>>>>>>>> probably could have used a much smaller in length rational to 
> >>>>>>>>>> get the desired number of 
> >>>>>>>>>> of terms in the cf for the number to letter conversion. 
> >>>>>>>>>> 
> >>>>>>>>>> What about the new cipher I propose using only numbers 1-7 in 
> >>>>>>>>>> the even positions -- 2,4,6,8,10,12,14.. 
> >>>>>>>>>> and group number identifiers 1-7 in the odd positions -- 
> >>>>>>>>>> 1,3,5,7,9,11,13.. 
> >>>>>>>>>> Think of it as using a slide rule where the private key 
> >>>>>>>>>> (a string of random letters along with each group number 
> >>>>>>>>>> identifiers) is on the fixed portion of the 
> >>>>>>>>>> rule and the slider portion has the cipher encrypted message 
> >>>>>>>>>> of just the numbers 1-7 and the 7 group identifiers. 
> >>>>>>>>>> These two strings are placed side by side and sliding the 
> >>>>>>>>>> ciphertext from left to right and aligning each letter 
> >>>>>>>>>> with the encrypted numbers of the sliding portion of the rule. 
> >>>>>>>>>> The examples I have previously posted --- 
> >>>>>>>>>> A letter is only used once in the left to right scan like the 
> >>>>>>>>>> word little the first T in little is used then the 
> >>>>>>>>>> scan continues by the decryptor for the second T because this 
> >>>>>>>>>> private key string is made up of 49 alpha 
> >>>>>>>>>> characters = 26*2 minus the second XYZ = 49 Alpha characters 
> >>>>>>>>>> and 1-7 group identifiers placed in the odd 
> >>>>>>>>>> count positions. Example below where this is easy to decrypt 
> >>>>>>>>>> by just this simple method -- 
> >>>>>>>>>> 
> >>>>>>>>>> ----------------------------------------------------------------------------------------- 
> >>>>>>>>>> Fixed private 
> >>>>>>>>>> key--------------------------------------------------------- 
> >>>>>>>>>> ----------------------------------------------"3KPMJNOL5VQSUWRT1KHMNJIL6IDCGHFE2BECGFDA7SOQUTRP4YAVXBWZ" 
> >>>>>>>>>> 
> >>>>>>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 > 
> >>>>>>>>>> Sliding cipher for the right letter alignment --- a public key 
> >>>>>>>>>> sent to be decrypted. moving --> then when reaching the end of 
> >>>>>>>>>> the fixed private key the cipher is brought back <--- (no scan ) 
> >>>>>>>>>> and scanning ----> again for the correct letter alignment to 
> >>>>>>>>>> be cherry-picked from the private key. 
> >>>>>>>>>> This is giving the whole cipher idea away but the order of the 
> >>>>>>>>>> characters in the private key can be drastically 
> >>>>>>>>>> changed along with the group identifiers then the public key 
> >>>>>>>>>> would be useless to the person without the new private string. 
> >>>>>>>>>> In a completed scan (end of too the right ------>), there 
> >>>>>>>>>> could be several stops for letter alignments. 
> >>>>>>>>>> I am just using this analogy of sliding but the right parsing 
> >>>>>>>>>> of strings in both algorithms would get the job done. 
> >>>>>>>>>> The above decryption of the public key above is easy if you 
> >>>>>>>>>> follow the rules. 
> >>>>>>>>>> This is just what I can remember from these old algorithms I 
> >>>>>>>>>> produced in basic on my commodore 64 back in the 80s 
> >>>>>>>>>> that worked great for encrypting and decrypting these numbers 
> >>>>>>>>>> only 1-7 ciphers. 
> >>>>>>>>>> Just trying to transfer these thoughts into Python but not 
> >>>>>>>>>> getting anywhere yet. 
> >>>>>>>>> Has anyone figured out, what I call, my seven square cipher yet? 
> >>>>>>>>> Or found any flaws in the concept? 
> >>>>>>>> Adding a level of security to any public key cipher of the above 
> >>>>>>>> nature the group identifiers could be changed 
> >>>>>>>> to a different identifier position after each message sent. 
> >>>>>>>> This way no patterns of odd position numbers can be detected 
> >>>>>>>> even though some 
> >>>>>>>> identifiers sometimes are used in succession breaking any 
> >>>>>>>> pattern possible with future cipher messages. 
> >>>>>>>> 
> >>>>>>>> You may ask, why did I reveal the secrets to this cipher? 
> >>>>>>>> Okay, Just say I presented the public key --- 
> >>>>>>>> 5,7,1,2,1,6,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,6,7,2,7 
> >>>>>>>> Then said, solve this cipher, what is the hidden written message 
> >>>>>>>> these numbers represent? 
> >>>>>>>> Duh, This is more powerful than even the German enigma machine. 
> >>>>>>>> This is because the public key encoded numeric message can be 
> >>>>>>>> any length but the 
> >>>>>>>> private key is just 56 characters long. 1-7 group identifiers 
> >>>>>>>> randomly located and the 49 Alpha characters. 
> >>>>>>>> In other words, I would die with this secret. ;-) 
> >>>>>>> 
> >>>>>>> That was stupid of me, The above cipher can be solved by anyone 
> >>>>>>> knowing the rules and the private 
> >>>>>>> key already revealed. 
> >>>>>>> 
> >>>>>> Also, if you are going to develop a cipher out of this, you need 
> >>>>>> to make 
> >>>>>> sure that every encryption generates a radically different 
> >>>>>> ciphertext, 
> >>>>>> even for the exact same plaintext. So encrypting the same plaintext 
> >>>>>> several times in a row would produce very different ciphertexts. 
> >>>>> Yes this is true, but because only 7 digits are used to pick an 
> >>>>> alpha character of 26 possibilities 
> >>>>> only the order of these 7 group identifiers is changed after each 
> >>>>> message 
> >>>>> The different combinations are 7! . A lot of messages (5048). 
> >>>>> Changed randomly. This way no letter connections 
> >>>>> other than a few out of 7 letters in a few groups after a few 
> >>>>> messages are sent but then complete contradictory results 
> >>>>> pointing to a letter involved with one particular identifier group 
> >>>>> of 7 letters. 
> >>>>> A bunch of test ciphertext would have to be processed to prove this 
> >>>>> point. 
> >>>>> The order right now of these group identifiers in this one example 
> >>>>> of the private key above is --- 3,5,1,6,2,7,4 and in 
> >>>>> odd positions in the private key alpha string --- 
> >>>>> 1,9,17,25,33,41,49 whose position never changes. 
> >>>>> 3,5,1,6,2,7,4 have 7! unique possibilities or (5040 possibilities) 
> >>>>> chosen from a random table of these possibilities. 
> >>>>> So only a 7 number change is necessary and once in a while change 
> >>>>> the random order (predetermined in a certain 
> >>>>> order of vowels and consonance strategically located in all the 
> >>>>> private string (groups of 7) should do the trick.. 
> >>>>> Did you solve the cipher yet? 
> >>>>> I gave plenty of info by using the slide rule method and the actual 
> >>>>> private key and ciphertext associated with it. 
> >>>> 
> >>>> I just ran an actual algorithm and the ciphertext has 2 corrections 
> >>>> you are supposed to solve against the private 
> >>>> alpha key. 
> >>>> When aligning an odd positioned group identifier from the public key 
> >>>> it can only draw one letter from that group 
> >>>> in the private key string. This is because the left to right 
> >>>> movement to align the identifier can't go back to the left 
> >>>> or stay in the same position on that identifier to choose the first 
> >>>> but not the second letter within the same group. 
> >>>> So here is the corrected ciphertext with 4 corrections -- 
> >>>> 5,7,1,2,6,1,7,1,1,6,7,1,4,2,3,5,6,7,4,6,1,6,6,2,2,2,4,2 
> >>>> It will be self-explanatory when you solve the cipher. 
> >>>> 
> >>> I am busy right now, but please post it over on sci.crypt. 
> >>> 
> >>> Using the same exact secret key, and encrypting the plaintext several 
> >>> times in a row should create different ciphertexts. Here is a crude 
> >>> example I made of my highly experimental fractal based encryption 
> >>> algorihtm. This funny fractal thing is radically different than my HMAC 
> >>> cipher. Anyway... 
> >>> 
> >>> Here are several ciphertexts that decrypt to the same exact plaintext 
> >>> using the default secret key using the following online program of mine: 
> >>> 
> >>> http://funwithfractals.atspace.cc/ffe 
> >>> 
> >>> The plaintext is: Hello World. 
> >>> 
> >>> 12 bytes 
> >>> 
> >>> 
> >>> ciphertext 0 
> >>> ______________________________ 
> >>> 
> >>> 0.07464055294813914 0.21413369654338263 
> >>> 0.18726842930653814 0.15381457747419044 
> >>> 
> >>> 13 65 3C 20 32 43 F4 50 66 9C 27 7A 
> >>> 
> >>> ______________________________ 
> >>> 
> >>> 
> >>> ciphertext 1 
> >>> ______________________________ 
> >>> 
> >>> 0.10712703156460045 0.3825663517793289 
> >>> 0.3822450385558595 0.18493372431673 
> >>> 
> >>> DF 2D 40 B5 C4 69 C0 C8 E8 9E 4C 99 
> >>> 
> >>> ______________________________ 
> >>> 
> >>> 
> >>> ciphertext 2 
> >>> ______________________________ 
> >>> 
> >>> 0.4562359936711957 0.21850028449704323 
> >>> 0.3486656373192471 0.3596603216576378 
> >>> 
> >>> 4A 81 3D 5E 3F 26 F7 CF FD 15 83 15 
> >>> 
> >>> ______________________________ 
> >>> 
> >>> 
> >>> 
> >>> To decrypt, copy-and-paste the text in between the lines into the Cipher 
> >>> Text box and click the Decrypt button. Better to use a desktop for the 
> >>> crude layout. 
> >>> 
> >>> 
> >>> This is using something called an IV. However, my HMAC cipher actually 
> >>> encrypts the random iv into the ciphertext itself. So, its not sent in 
> >>> the clear. Read all of: 
> >>> 
> >>> http://funwithfractals.atspace.cc/ct_cipher 
> >>> 
> >>> Also, read all of: 
> >>> 
> >>> https://groups.google.com/g/comp.lang.c/c/a53VxN8cwkY/m/WIxIwoK7DAAJ 
> >>> 
> >>> 
> >>> Actually, try clicking Encrypt multiple times and take a look at what 
> >>> happens to the ciphertext. 
> >> 
> >> Chris, 
> >> It appears to create a few more encrypted 2 character codes than the 
> >> actual number of alpha characters 
> >> in the plaintext in a one-for-one matchup. 
> > 
> > My highly experimental FFE cipher creates a ciphertext hexbyte for each 
> > plaintext character. Can you show me an example plaintext where it 
> > creates more? This is different than my HMAC cipher that can extend the 
> > ciphertext and make it larger than the plaintext via using TRNG random 
> > bytes in the plaintext before encrypting. read all: 
> > http://funwithfractals.atspace.cc/ct_cipher 
> > 
> > Now, back to my FFE. So, encrypting Hello using the default key can be: 
> > _______________________ 
> > 0.12934470968540027 0.025161836871791087 
> > 0.03337929216249355 0.11671759502753765 
> > 
> > FF 19 E6 62 D5 
> > _______________________ 
> > 
> > 5 Hexbytes FF 19 E6 62 D5. 
> > 
> > If you can give me a plaintext that creates more than hexbytes than the 
> > number of characters in the plaintext, please show me! 
> > 
> >> Interesting what is going on there. 
> >> Also, what are the number of mathematical possibilities of creating 
> >> these 2 unique character codes of a mix 
> >> of alpha-numeric or just alpha, or just numeric to give a final 
> >> total of possibilities? 
> >> Is it 26! *10! ? Probably not that big. 
> > 
> > I am not sure. It depends on how many different secret keys one can make
> > and how many possibilities of getting the same exact random IV.[...] 
> 
> Then again, using the example above with Hello at hexbytes: FF 19 E6 62 
> D5, it would be 5 16-bit numbers. So, the probability would be the 
> chances of rolling 5 16 sided die and getting a result X. Okay, now how 
> many times do we need to roll to get X again? Each roll would be a click 
> of the Encrypt button for the same plaintext and secret key. Yes, the 
> secret key comes into play. Because FF 19 E6 62 D5 does not work with 
> another secret key that was not used to create it.

One big question?
A possible scenario --
Joe the encryptor has his own offline encryption algorithm in a computer.
He copies the encrypted message on a thumb drive and loads it into his
online computer and sends the encrypted message to his foreign opertive
Alice.
Is some other info coming along with that encrypted message?
There could be something berried in the encrypted hex code?
My big question is, has this been tried on two separate offline
systems?
If this was all done on one system, I was snookered if not then this is 
fantastic. 
On the encryption side algorithm --- plaintext read in.
On the decryption side hex coding  -- read in.
Two separate systems.
A Huge advantage if both algorithms are on one system to 
pull a fast one. 
Or a possibility much more data is coming across than just the encrypted message?

Just my take an opinion.
Not accusing you of anything because you have much more talent than I on fractals
and the whole structure of the two, I hope, separate systems.(encryption,decryption)
The question needs to be asked.

Whatever just keep producing these great renderings which I find fascinating.
Also what you produced here, even if it was only on one system. 

Dan
      

[toc] | [prev] | [next] | [standalone]


Page 3 of 6 — ← Prev page 1 2 [3] 4 5 6  Next page →

Back to top | Article view | sci.math


csiph-web