rotor replacement

[=?ISO-8859-1?Q?=22Martin_v=2E_L=F6wis=22?=]

If he understood how Python is actually used, he'd understand that any
C module is a lot more useful in the core than out of it.

This is non-sense. I have been distributing C modules outside
the core for quite some time now, and I found that the modules
are quite useful. distutils makes it really easy for anybody
to use them.

There are already tons of
3rd party crypto modules outside the core, and the module I was
writing wouldn't add anything useful to those.

Why do you think these are not part of the core? It's not because
they contain crypto code, or because they had been rejected. They
are primarily not included in Python because they have not been
contributed to Python, yet.

If they were contributed, a number of things still would need to
be considered, e.g. what is the size of the code, including libraries,
is the contributor really the author, is the code likely going
to be maintained, and so on. However, it never got that far.

Where does Frederik get
off lecturing me about wanting to get a module into the core, when
Guido had invited me to do precisely that with that very module?

I know that *I* am very opposed to any contribution of a larger
module that has not seen any real users, yet. So if the module
was primarily written to be included in the core, I would initially
reject it for that very reason. After one year or so in its life,
and a recognizable user base, inclusion can be considered.

I did release a replacement for the rotor module that's written in
Python, which means it's reasonably useable without being in the core.
However, while its security should be ok, to provide reasonable
performance it had to use a nonstandard algorithm and therefore isn't
good for interoperating with anything. To be both acceptably fast and
interoperable with other applications, a C module is needed.

I fail to see the problem you seem to have with C modules. They are
very easy to use if written properly.

Regards,
Martin

 

[Fuzzyman]

I also feel the lack of a standard cryptography module in the core...
even a *basic* one. At least rotor provided that, before it was
deprecated. I (along with many other python users) write CGIs where the
only extension modules that I can use are either pure python, or ones
my web hoster is willing to install. Luckily my hoster will install
modules without too much fuss - others aren't so lucky. Cryptography is
a pretty 'standard' requirement these days.. and IMHO ought to be in
the 'standard library'.

Without commenting (or reading properly) on this exchange... it does
seem that many of '<F>'s contributions have been very bad tempered
recently. Hmmm.....
Regards,

Fuzzy
http://www.voidspace.org.uk/python/index.shtml

 

[phr]

I also feel the lack of a standard cryptography module in the core...
even a *basic* one. At least rotor provided that, before it was deprecated.

Rotor was insecure and really shouldn't have been used. If you need
crypto in pure Python, try this:

http://www.nightsong.com/phr/crypto/p3.py

It's a nonstandard algorithm, but so was rotor. Its security should
be much better than rotor's, and its speed should be tolerable for
most purposes.

 

[phr]

[Note: this is a 2nd attempt at posting reply to Martin's message,
since the first one didn't reach the server. It's a rewrite from memory
but says about the same thing as the other attempt. --Paul]

This is non-sense. I have been distributing C modules outside the
core for quite some time now, and I found that the modules are quite
useful. distutils makes it really easy for anybody to use them.

Maybe we're not thinking about the same problems. Say I'm an app
writer and I want to use one of your modules. My development
environment is GNU/Linux, and I want to ship a self-contained app that
anyone can run without having to download additional components. That
includes people wanting to run my app on Windows, Macintosh, Amiga,
and various other Python target platforms that I don't have compilers
for. How do I do it?

I'm sure your modules are excellent but as an app writer, I feel I
must try to avoid needing them, in favor of modules that are already
in the core, even if it means more work for me or worse functionality
in my app, just for the sake of reducing installation headaches for my
target audience. So, if your modules are generally useful, I hope you
will try to get them into the core.

Why do you think these are not part of the core? It's not because
they contain crypto code, or because they had been rejected. They
are primarily not included in Python because they have not been
contributed to Python, yet.

I can't speak for the authors but I'd personally say that none of
those old modules are really suitable for the core on technical
grounds. They're too fancy and specialized, or they depend on
external libraries like OpenSSL, or they're written mostly to support
some specific application and don't present a simple, general-purpose
interface like a core module should have. Maybe the authors felt the
same way and chose not to submit them. Or maybe the authors had other
reasons, such as licensing priorities that conflict with the Python
license.

The module I'm discussing would simply implement the FIPS standard
block ciphers (AES and DES) and the FIPS operating modes. These are
the basic building blocks that I feel are missing from the core. They
should be enough to fill the crypto needs of most applications.

If they were contributed, a number of things still would need to
be considered, e.g. what is the size of the code, including libraries,
is the contributor really the author, is the code likely going
to be maintained, and so on. However, it never got that far.

The module we're talking about wouldn't have had any of those problems.

I know that *I* am very opposed to any contribution of a larger
module that has not seen any real users, yet.

We're not talking about a "larger module", we're talking about a
module that implements the basic AES and DES block ciphers (similar to
how the sha module implements the basic SHA-1 hash algorithm) and
wraps them with some well-defined FIPS operating modes (similar to how
the hmac module wraps the sha module to compute RFC 2104 hmac
authentication codes). This stuff isn't rocket science. It's just
straightforward implementation of modes and algorithms that go back to
the 1970's, are the subject of national and international standards,
and are already in use in thousands of non-Python applications all
over the world.

Also, I've already released a pure-Python implementation of the
interface, suitable for application testing but too slow for real use.
I tried rather hard to design a convenient and general interface that
I feel was an improvement over PEP 272. I don't know if anyone except
me is using it, but several people including Andrew (author of PEP
272) have written favorably about it based on reading the
specification. The spec was designed from the beginning to fill the
needs of the core. If I were writing it as a non-core module I would
have included more stuff.

So if the module was primarily written to be included in the core, I
would initially reject it for that very reason. After one year or so
in its life, and a recognizable user base, inclusion can be
considered.

That makes no sense; improving the core is a perfectly valid reason to
write something. If someone wrote a straightforward patch that made
the Python interpreter 3x faster, would you still want to wait a year
before thinking about including it? I certainly believe that every
contribution needs code review and user testing before entering wide
release, but that doesn't seem to be what you're getting at.

I fail to see the problem you seem to have with C modules. They are
very easy to use if written properly.

Well again, maybe we're not talking about the same thing, or perhaps I
just need more explanation of what you mean. Suppose I want to write
an "application" that tells people the SHA-1 checksum of their name.
I write 3 lines of Python using the built-in sha module:

import sha
name = raw_input('Enter your name: ')
print 'Your hash is', sha.new(name).hexdigest()

I release this "app" and presto, every Python user on every OS
platform can run it with no fuss. That includes CGI authors who
aren't allowed to install C modules at all, without getting their
hosting service to do it. How do I do the same thing if there's no
built-in sha module and all I have is sha.c?

To me, the whole Python notion of "batteries included" expresses
precisely the idea that I'm trying to describe. Commonly-used
functions belong in the core, because making people download or
install them separately is a pain in the neck.

 

[Fredrik Lundh]

Maybe we're not thinking about the same problems. Say I'm an app
writer and I want to use one of your modules. My development
environment is GNU/Linux, and I want to ship a self-contained app that
anyone can run without having to download additional components. That
includes people wanting to run my app on Windows, Macintosh, Amiga,
and various other Python target platforms that I don't have compilers
for. How do I do it?

have you tried this, or are you just making things up to be able to continue
the argument? (hint: it doesn't work; python portability means that it's fairly
easy to write programs that run on multiple platforms, not that they will run
on all available platforms without porting and testing).

</F>

 

[phr]

have you tried this, or are you just making things up to be able to
continue the argument? (hint: it doesn't work; python portability
means that it's fairly easy to write programs that run on multiple
platforms, not that they will run on all available platforms without
porting and testing).

As an app writer I want to publish code that runs on multiple
platforms without needing special attention from the end user, and
preferably without needing special platform-specific attention from
me. If you want to use the words "Python portability" to mean
something weaker than that, that's ok, but I'm trying to accomplish
something better. I've written lots of Python code that uses the sha
module without my needing to worry about the target platform, so that
shows the goal can be met. I'm aiming for an aes/des module that's as
convenient for app writers and end users as the sha module is.

So now I know what you think "Python portability" means. What do you
think "batteries included" means?

 

[Fredrik Lundh]

As an app writer I want to publish code that runs on multiple
platforms without needing special attention from the end user, and
preferably without needing special platform-specific attention from
me.

please answer the question: have you done this? what kind of programs
have you successfully delivered as "self-contained apps" for use on arbi-
trary platforms?

</F>

 

[phr]

please answer the question: have you done this? what kind of programs
have you successfully delivered as "self-contained apps" for use on arbi-
trary platforms?

Here's a simple one:

import sha
name = raw_input('Enter your name: ')
print 'Your name hashes to:', sha.new(name).hexdigest()

Maybe the sha module isn't in fact available on all platforms, but
it's definitely available on more platforms than I personally have
compilers for. Maybe some more complicated app will hit some
non-sha-related platform dependency and present a porting problem.
But it's worse if it has additional porting problems caused by the sha
module. Making the sha module available on multiple platforms is a
good thing regardless of what the rest of the app does. Doing that
means one less porting problem to worry about. So your question is an
irrelevant misdirection.

Anyway, I've written Python code that that's run under Linux and
Windows and the Macintosh without needing porting. That's not the
same as testing on every platform Python runs on, but if one of those
platforms fails other than from using a builtin module that's
documented as being platform specific, especially if the module is a
pure mathematically-defined algorithm like sha and not an OS-interfacing
module like threading or Tkinter, then I'd say the portability bug is
in Python or its library, not in my app.

 

[=?ISO-8859-1?Q?=22Martin_v=2E_L=F6wis=22?=]

Maybe we're not thinking about the same problems. Say I'm an app
writer and I want to use one of your modules. My development
environment is GNU/Linux, and I want to ship a self-contained app that
anyone can run without having to download additional components. That
includes people wanting to run my app on Windows, Macintosh, Amiga,
and various other Python target platforms that I don't have compilers
for. How do I do it?

This is not possible - whether the module is included in Python or not.
People *will* have to download something besides your application,
namely Python - and in the version your require, too. If they cannot
compile Python themselves, they will have to find somebody who did that
for them.

This is very easy if you are using Windows, Debian, or Mac OS X.
It is very difficult if you are using an Amiga, or any of the other
Python target platforms that you don't have compilers for. HP-UX
users of your application will have a hard time to get it running
even if the module was available as a built-in.

This does not change much if the module is available separately,
and it does not change much whether the separate module is written
in Python or in C: Windows, Debian, and OS X users will still
find precompiled binaries for the module, and all others will still
have to build it themselves. This is very easy, since all they have
to do is to use distutils.

So, if your modules are generally useful, I hope you
will try to get them into the core.

Right - the critical condition is "if the modules are generally
useful". I cannot possibly know whether they are generally useful
until a general public has commented that they are.

I can't speak for the authors but I'd personally say that none of
those old modules are really suitable for the core on technical
grounds.

That is my impression, too.

The module I'm discussing would simply implement the FIPS standard
block ciphers (AES and DES) and the FIPS operating modes. These are
the basic building blocks that I feel are missing from the core. They
should be enough to fill the crypto needs of most applications.

Hmm. Most applications don't have any crypto needs. Those that do
typically need TLS, or secure password hashing (crypt(3) specifically).
So I somehow doubt that an AES module would be generally useful.

That makes no sense; improving the core is a perfectly valid reason to
write something. If someone wrote a straightforward patch that made
the Python interpreter 3x faster, would you still want to wait a year
before thinking about including it?

I would have to apply the "generally useful" test. For an 3x speed
improvement, about 100% of the Python users would find that useful.
For an AES module with an interface nobody has ever used but yourself,
it would be very difficult to argue that the module is generally useful.

If the module does not serve a need that people have, in general,
I don't see why it should be included (and yes, I wish a few of the
modules that were included recently wouldn't have been added so
quickly).

I certainly believe that every
contribution needs code review and user testing before entering wide
release, but that doesn't seem to be what you're getting at.

I'm primarily looking for the user testing. I require that this happens
*outside* the Python distribution. Make a distutils package, and report
the user feedback. Then propose inclusion into the core.

I release this "app" and presto, every Python user on every OS
platform can run it with no fuss. That includes CGI authors who
aren't allowed to install C modules at all, without getting their
hosting service to do it. How do I do the same thing if there's no
built-in sha module and all I have is sha.c?

It very much depends on the details of the target system. Yes,
it is a bit more tricky to install the additional library - but
that is the case with any additional library, whether it is C
or not.

For the CGI user who is not allowed to install binaries into
/usr/local, she can still install the module in her home
directory, no?

To me, the whole Python notion of "batteries included" expresses
precisely the idea that I'm trying to describe. Commonly-used
functions belong in the core, because making people download or
install them separately is a pain in the neck.

See, this is the critical point: "commonly-used functions", not
"functions I believe would be commonly used". You must have
*existing* users for a function to be commonly-used.

Regards,
Martin

 

[James Stroud]

Martin v. Löwi said

Hmm. Most applications don't have any crypto needs.

Any program where one stores data would have crypto needs.

Here are some examples: Database, wordprocessor, spreadsheet, address
book, mail program, (should I go on?). What would be the alternative to
encryption to satisfy the functionality encryption
provides...memorization? But I believe this may be a case of things
being so obvious people forget their importance (e.g. breathing).

I have written a class that goes something like this (highly simplified)

class encryptFilter:
def __init__(acipher):
self.mycipher = acipher
def open(self, filename):
self.myfile = open(filename,"w")
def write(data):
encrypted_data = self.encrypt(data)
self.myfile.write(encrypted_data)
etc...

Now what if acipher and this class could be made from part of the core
distro? Any application could have the option of encryption with only a
few lines of code:

import std_crypt

# other code here

if get_user_pref("do_encryption"):
password = my_get_password()
acipher = std_crypt.AES(password)
outfile = std_crypt.encryptFilter(acipher)
outfile.open(filename)
else:
outfile = open(filename,"w")

# all other code doesn't change...
outfile.write(buncha_data)


This could be even more simpler, but that's the general idea. The
usefulness would be tremendous.

 

[Peter Hansen]

Martin v. Löwi said

Any program where one stores data would have crypto needs.

James, you must have mistyped the above, or your logic
is quite flawed.

I have written dozens of programs which store data, and
only a couple have had any crypto needs. This alone
invalidates your statement as it stands.

What did you really mean to say? Maybe "could" instead
of "would"? That would make the statement true, yet
somewhat pointless, and it doesn't contradict what
Martin wrote in either case.

-Peter

 

[Terry Hancock]

have you tried this, or are you just making things up to be able to continue
the argument? (hint: it doesn't work; python portability means that it's fairly
easy to write programs that run on multiple platforms, not that they will run
on all available platforms without porting and testing).

I don't know, they come pretty close. Problems with portability in pure-python
modules have been almost non-existent for me. I almost never test on the
Windows platform, but I know some of my code is being used by Windows
users. And I guess I won't start, really, because I haven't heard any complaints
about it breaking.

I *did* have a few problems with Zope packages running on FreeBSD, bizarrely
enough, given that it's in the "POSIX" family of OSs, and therefore seems very
similar on the surface.

And, well, I'm sorry Mr. Lundh, but your PIL module actually is something
of a pain to install still. The OP is right about that. Usually worth it, but I don't
like the fact that that pain is being passed on to the end-user of my software.

The fact that you got all snide and refused to work with me when I asked
for a copy of the autoconf sources to try to fix the problem didn't make me
too happy, either. So, naturally, I just dropped it. I'm in no position to
pick it up now -- just don't need it badly enough now (AFAIK it's unchanged
still -- lately I've been using the Debian package though, so I don't have to
worry about it).

I know that you don't want PIL to go into the core, of course, but I'm pretty
sure that problem would've needed fixing, if it were to be introduced.

Small problem, trivial to fix, but that's what bothers me about it.

Terry

 

[James Stroud]

I was purposefully making an illogical statement to illustrate the lapse
in reason of Martin's statement. Users have crypto needs, not
applications. Applications are presumably not anthropomorphic enough to
have needs--hence the lack of logic.

However, I am not an application (as far as you or I know) and thus can
not truly speak to the needs of applications in general, if indeed they
have any.

Applications that lack features force users to accept a limited feature
set or they use an alternative program with other limitations. Putting
the possibility for cryptographic storage increases the utility of any
application that stores data, and it could be done without much work if
it were properly included in the core distribution. I have found it
amazing how few programs include encryption as an option. I believe this
is because its hard for programmers to include it and/or they falsely
reason that "if I don't need it, the user doesn't", which is up there
with "if I can't see them, then they can't see me" in terms of bad
logic.

James

 

[phr]

Applications that lack features force users to accept a limited feature
set or they use an alternative program with other limitations. Putting
the possibility for cryptographic storage increases the utility of any
application that stores data, and it could be done without much work if
it were properly included in the core distribution. I have found it
amazing how few programs include encryption as an option. I believe this
is because its hard for programmers to include it and/or they falsely
reason that "if I don't need it, the user doesn't", which is up there
with "if I can't see them, then they can't see me" in terms of bad logic.

The likely-best-known Python application in the world (probably more
people have heard of it than have heard of Python) originally had
crypto (an AES module distributed as a C extension with the beta test
versions of the app) but the crypto was brutally ripped out of the
application for the final release (you can still see scar tissue in
the code where the crypto was, i.e., there's still a function called
something like "encrypt_packet" which no longer actually encrypts the
packet). I haven't found out exactly why the crypto was removed so I
can't be certain that it's because of cross-platform installation
headaches. I do know that its author wanted an AES module in the core
to use for that application, in order to not have to distribute a C
extension, and he did some of the early work with me on writing such a
module to submit for that purpose. The module I ended up proposing is
an offshoot of that effort.

 

[phr]

[Again I'm having news server trouble and made a previous attempt to
post this, so sorry if you see it twice. This version is edited
somewhat from the previous.]

This is not possible - whether the module is included in Python or not.
People *will* have to download something besides your application,
namely Python - and in the version your require, too. If they cannot
compile Python themselves, they will have to find somebody who did that
for them.

Sorry, the presumption is that they already have Python installed.

Right - the critical condition is "if the modules are generally
useful". I cannot possibly know whether they are generally useful
until a general public has commented that they are.

There is considerable demand for a crypto module. Note how this thread
started: someone who had been using the rotor module complained that it's
now missing.

Hmm. Most applications don't have any crypto needs. Those that do
typically need TLS, or secure password hashing (crypt(3) specifically).
So I somehow doubt that an AES module would be generally useful.

I believe it's feasible to do TLS in pure Python with acceptable
performance, given a DES module and the existing sha module. I think
Trevor Perrin has already written something like that. It's feasible
because outside of bulk crypto operations using DES and SHA, TLS's
execution time is dominated by public-key math calculations, which are
acceptably fast using Python's built-in longs. The rest of the stuff
like certificate parsing happens just once per session and doing it in
Python isn't too awful. On the other hand, it's impossible to do a
general purpose TLS stack acceptably without a DES module. According
to RFC 2246 sec. 9, supporting TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA is
mandatory unless the application profile specifies otherwise. SHA is
already in the core and DHE/DSS can be done with Python longs, so DES
is the missing critical piece.

Also, since DES is in the process of being decertified and AES is its
replacement, supporting DES without supporting AES is silly. GnuPG
for example uses AES by default, so writing an interoperating Python
application (I have some parts of one working) needs AES.

If by crypt(3) you mean the old thing of DES with the modified E
table, I don't think it's used much any more. I don't see any reason
against adding it if people want it, but it's not an encryption
function, it's an authentication function, and shouldn't be subject to
the legal concerns of a general purpose encryption module.

I do think it would be nice to have TLS in the core someday, just like
it's already in the Java distro (JSSE). However, that's much more
ambitious and anyway it would rely on the block cipher module, so the
block cipher module is needed anyway. Meanwhile, a pure-Python TLS
implementation outside the core is ok as a workaround. Getting more
pure Python modules into the core is in general less valuable than
getting more C modules into the core.

For an AES module with an interface nobody has ever used but yourself,
it would be very difficult to argue that the module is generally useful.

Eh? Lots of people have asked for general purpose crypto modules, and
the interface follows the approach used by any number of existing
libraries. It just does exposes the simplest possible interface to
the block cipher and then implements the FIPS operating modes in a
natural and obvious way. I've used a number of other such libraries
and am pretty familiar with what they need to do. The main thing it
tries to do differently from PEP 272 is separate the block ciphers
from the FIPS modes, so that each new cipher module doesn't have to
implement all the different modes.

I hadn't thought there was any controversy over the technical side of
this. There's the legal/political issue which I can gently suggest is
overblown, but since I'm not the one who would have to take the heat
if some government bigwig somewhere flipped their lid over crypto in
the Python distro, I don't feel entitled to be very vociferous about
this aspect.

I'm primarily looking for the user testing. I require that this happens
*outside* the Python distribution. Make a distutils package, and report
the user feedback. Then propose inclusion into the core.

I'm happy to have that kind of testing (and I requested it), given
that the goal is inclusion in the core, and the core developers have
told me (as they did) that the proposal looks good and they'd like to
have the module, so I can reasonably expect it to go into the core if
it meets its technical expectations.

If the developers instead say (as they seemed to somewhat later) that
because of legal/political concerns, there's no way the module can
possibly go into the core no matter how good it is technically, then
my motivation for writing the module dries up quite a bit. If someone
wants to pay me a salary to write it anyway, I might be interested,
but people who work as volunteers get to pick their own reasons for
doing things or not doing them.

It very much depends on the details of the target system. Yes,
it is a bit more tricky to install the additional library - but
that is the case with any additional library, whether it is C or not.

I don't see this. If a library is pure Python, I can always include
it with the application. If it's in C, somebody has to compile and
install it, and I as the app writer may not have access to compilers
for the target platform. Of course a Python library might have
platform-dependent OS calls or other configuration hair, but that
shouldn't apply to a pure mathematical function that's written
portably and makes no OS calls at all.

For the CGI user who is not allowed to install binaries into
/usr/local, she can still install the module in her home
directory, no?

Evidently not always. And how would the CGI user create a binary
anyway, even given a way to install it, if the web hosting service is
using a platform that the CGI user doesn't have a compiler for? Think
of a Mac user whose web host runs Windows, or vice versa.

See, this is the critical point: "commonly-used functions", not
"functions I believe would be commonly used". You must have
*existing* users for a function to be commonly-used.

You're going around in circles. DES and AES have millions of users.
They have few Python users because the functions aren't available in
Python. To fix that, they must be added to Python. How many users
do you think the Python sha module had before it went into Python?

--Paul

 

[Fredrik Lundh]

And, well, I'm sorry Mr. Lundh, but your PIL module actually is something
of a pain to install still. The OP is right about that. Usually worth it, but I don't
like the fact that that pain is being passed on to the end-user of my software.

The fact that you got all snide and refused to work with me when I asked
for a copy of the autoconf sources to try to fix the problem didn't make me
too happy, either.

ah, you're the guy who flamed me and called me names because PIL didn't
fit some hypothetical GNU-inspired definition of "open source software." it's
always sad when people have to attack those who don't share their religion,
but it's not that much I can do about that.

So, naturally, I just dropped it.

which means that you have no idea how easy or hard it is to install PIL today
(hint: things have changed)

</F>

 

[Fredrik Lundh]

The likely-best-known Python application in the world (probably more
people have heard of it than have heard of Python) originally had
crypto

and what Python application is that? I can think of quite a few applications
written in Python that are widely known, but none of these are distributed as
Python code to end users.

I do know that its author wanted an AES module in the core
to use for that application, in order to not have to distribute a C
extension

</F>

 

[Robert Kern]

and what Python application is that? I can think of quite a few applications
written in Python that are widely known, but none of these are distributed as
Python code to end users.

BitTorrent, probably.

I believe that a very high percentage of users get the BitTorrent apps
as standalone executables, not as a Python package where one has to go
download Python first. The ones that do get it as Python source probably
get it from their Linux/FreeBSD/other distribution where such
dependencies are also taken care of for them.

--
Robert Kern
(e-mail address removed)

"In the fields of hell where the grass grows high
Are the graves of dreams allowed to die."
-- Richard Harter

 

[Fuzzyman]

I've already downloaded p3 - thanks

I wonder how long it took (in reality) an average hacker to break the
algorithm used by rotor ?
Regards,

Fuzzy
http://www.voidspace.org.uk/python/index.shtml

 

[=?ISO-8859-1?Q?=22Martin_v=2E_L=F6wis=22?=]

I hadn't thought there was any controversy over the technical side of
this.

There isn't. The interface might be beautifully designed, and you might
claim it is, and I would *still* require that the module gets field
testing before being incorporated into Python. If other people start
attesting that the module is beatifully designed, and should be included
in the Python core - *then* it is worth looking into inclusion.

I'm happy to have that kind of testing (and I requested it), given
that the goal is inclusion in the core, and the core developers have
told me (as they did) that the proposal looks good and they'd like to
have the module, so I can reasonably expect it to go into the core if
it meets its technical expectations.

Not if I have a say in it. *Any* new module should see out-of-the-core
distribution first (unless there is BDFL pronouncement to include it,
of course).

This really is a matter of development process, not of technical
quality.

If the developers instead say (as they seemed to somewhat later) that
because of legal/political concerns, there's no way the module can
possibly go into the core no matter how good it is technically, then
my motivation for writing the module dries up quite a bit.

I personally would not say that, although I can imagine that some people
do say that, and I would also defend an inclusion, and push compliance
the BXA requirements so we can legally export Python out of the
U.S.A.

Evidently not always. And how would the CGI user create a binary
anyway, even given a way to install it, if the web hosting service is
using a platform that the CGI user doesn't have a compiler for? Think
of a Mac user whose web host runs Windows, or vice versa.

In either case, the user would best use the pre-compiled binary that
somebody else provided for the platform. Actually, the Windows user
using an OS X CGI server can probably just invoke the gcc which is
on the target system, anyway.

You're going around in circles.

No, I'm merely repeating myself, and rephrasing each time.
I have to, because apparently you don't see what my requirement
is.

They have few Python users because the functions aren't available in
Python. To fix that, they must be added to Python. How many users
do you think the Python sha module had before it went into Python?

The original source code of the SHA-1 implementation is the NIST code
(Gutmann, then Hollerbach), so I guess that had hundreds of users before
the module was contributed to Python. The module itself (including the
API) was written by Greg Stein and Andrew Kuchling. I believe (without
being able to verify) that they distributed this module for quite some
time, before contributing it to Python. We would have to ask them
how many users they had until they felt confident to contribute the
code.

Regards,
Martin

Andrew Kuchling