Blog of Gonzalo Brusella » Development

The different flavors of the Orbital Ion Cannons (DDoS attack tools)

gbrusella — Wed, 15 Dec 2010 16:12:56 +0000

WARNING: This is just a study on the tools. I DO NOT encourage you to use them. The source code that I will show is intended to be used ONLY on learning purposes.

On my last entry, you found that the Anti-Anti-Wikileaks (Pro Wikileaks, you know all about double negations) groups are using LOIC (Low Orbit Ion Cannon) to provoke DDoS attacks on several sites.

So far I have found 3 tools that makes all the “good” job.

LOIC: It means “Low Orbit Ion Cannon”, and is an open source network stress testing application, written in C#. Initially developed by Praetox Technologies but later released in the public domain. Can be found here: http://sourceforge.net/projects/loic/, but the root is: http://praetox.com/n.php/sw/sauce. This tool used Framework 3.5, but if it’s upgraded to .Net 4 and makes use of TPL (yes, I did it, and NO I WON’T release it’s source) can gain some more performance.
- IRC LOIC: Found on https://github.com/NewEraCracker/LOIC/zipball/1.1.2.3 this is the source of the (one of the latest?, you need to lurk more seriously on 4chan’s /b forum to see if there is a newer version) versions of LOIC. It varies from the original LOIC on the fact that it can connect to a IRC server and be controlled from a room by it’s operators (the users prefixed by “@”) . This creates a voluntary botnet called “Hive Mind”. It’s controlled by the members of Anonymous Group.
- LOIQ: Located on http://sourceforge.net/projects/loiq/, is a C++/Qt4, port of the original LOIC intended to be executed on X (Mainly Linux, but also Mac OS X).
- JS LOIC: http://anonsp.hostoi.com/ is a JavaScript version of LOIC. Much less effective, but also with no download/install requirements. The source code is in the page’s source code .
- JavaLOIC: http://www.mediafire.com/?9rfblvej3ycd8dt Not open sourced, but the .jar file is not secured. Maybe the source can be obtained after using a Java Decompiler
HOIC: It means “High Orbit Ion Cannon”. Located on http://hoic.99k.org/ it claims to be open sourced, but I couldn’t find the source. It Cannot be remotely controlled, but is way more powerful than LOIC.
GOIC: Acronym of “Geosynchronous orbital ion cannon” http://pastebin.com/FH6njMew is a public domain tool that has been released but has no transcendence (so far).

As you can see, there is a lot of tools being used, on this matter, but those are the ones related to the Wikileaks-Anonymous matter (as far as I know)

Haking Infography

gbrusella — Sat, 29 May 2010 23:57:18 +0000

Here is a “little” and very condensed history of hacking. A remarkable mention to Nash.

Via: Online MBA

TEDx Buenos Aires Soon!!

gbrusella — Mon, 05 Apr 2010 14:38:07 +0000

I’m VERY exited about this… The first TEDx (x is for independent talks) in Buenos Aires is about to be materialized next April 8… And I got my ticket!! Finding one was a truly adventure. Just 1 in 6 or 7 pre-registered got his ticket.

But.. What is TED?

TED is a small nonprofit devoted to Ideas Worth Spreading. It started out (in 1984) as a conference bringing together people from three worlds: Technology, Entertainment, Design. Since then its scope has become ever broader. Along with the annual TED Conference in Long Beach, California, and the TEDGlobal conference in Oxford UK, TED includes the award-winning TEDTalks video site, the Open Translation Program, the new TEDx community program, this year’s TEDIndia Conference and the annual TED Prize.

And TEDx is…?

TEDx was created in the spirit of TED’s mission, “ideas worth spreading.” The program is designed to give communities, organizations and individuals the opportunity to stimulate dialogue through TED-like experiences at the local level. At TEDx events, unique talks given by live speakers combine with TEDTalks videos to spark deep conversation and connections. TEDx events are fully planned and coordinated independently, on a community-by-community basis.

I left here some of my favorites…

The Ballmer Peak

gbrusella — Thu, 18 Mar 2010 16:28:19 +0000

I’ve just saw this on XKCD… Impressive.

Microsoft Live Labs Pivot project

gbrusella — Sat, 19 Dec 2009 04:28:41 +0000

Microsoft Live Labs has a new baby: Pivot.

Pivot makes it easier to interact with massive amounts of data in ways that are powerful, informative, and fun. We tried to step back and design an interaction model that accommodates the complexity and scale of information rather than the traditional structure of the Web.

My firt impression: Huuge potential. It is what I think that future search methods should be. A mix between related data, context information, and visual search. The only thing that I cannot undestabd is why only visual search… we have a lot of algorithms to index media… we can do more…

It uses Deep Zoom (a technology that is part of silverlight) that allows to render images in a smart way (Note to me: Must do a Post on how Deep Zoom works) to render the collections.

You can get an invitation by following the dev team in twitter.

.Net News

gbrusella — Sat, 19 Dec 2009 03:45:43 +0000

I have been using Visual Studio 2010 Beta 2 and TFS 2010. They are awesome!

VS2010 is going to be a great poroduct, when it goes RTM. I see a lot of effort on making may life as developer a lot more easy. The integration with Visual Studio Gallery is good (could be better, like allowing to search by cost of the extension, more a la site version). On the PDC 2009 MS that the free version of Code Rush will also be available for Vs2010 developers.

I will include some captures as soon as possible.

On the TFS 2010 side, it’s becoming a serious contender on his segment. Now with a native integration with project server, the managers can concentrate all the info in just a a tool and get an updated snapshoot on the project status every time they want.

Also the new compilation farms are nice. The compilation process is now Workflow based, so you can adjust the process with custom activities as you need. That and much more to come.

Playing With… Oxite!

gbrusella — Tue, 17 Nov 2009 03:50:24 +0000

Right now I am playing With Oxite a Open source CMS made by Microsoft. This is an Alpha release and I must Admit, once i managed to build it (yes, the setup process needs some corrections, but the comments helps a lot with the process).

Once it has been compiled… works like a charm. It is a low end blog. It does not have any of the fancy or the minimum features yet (ie: No RSS/Atom, no anti-spam). The developers also say that is not production ready yet… but I saw some sites using it.

Adding this features seems quite easy since the plug-in/module model is very easy to understand and to code. Rumors say that the Beta version is very close… I’m very happy with this.

Nice code. A Big plus is that my preliminary analysis shows that the persistency layer (it uses a LinqToSql provider) seems quite easy to replace with a more malleable ORM.

In summary: this is a project that you must watch.

Google Wave Embedd Sample

gbrusella — Fri, 13 Nov 2009 18:19:08 +0000

Me And my friend Ivan are waving a little.

Working with HL7 Part 2

gbrusella — Wed, 14 Oct 2009 04:14:00 +0000

I am not a person who loves to leave all things unfinished. This is no exception.

A while ago, I started blogging about how to work with HL7 in an easy way. I had to deal with it and I can guarantee you, my reader, that in some cases is not an easy task. On the first part I wrote about the structure of an HL7 message; now is time to handle this message in a systemic way (aka: developing).

While you have integration suites (I remember a few: Microsoft’s BizTalk, Oracle’s Fussion, SAP PI, etc.), some times you don’t need a über product for getting the job done. Sometimes it is perfect to write your-own-and-very-flexible code.

After googling a while, I found a little jewel for us developers. HAPI for Java developers and NHAPI for .Net ones. The original project is the Java one, so if you need some documentation you should go to the source project.

Now you got the essentials. It is time to show you some code, but first a little of context.

Recently I had to deal with the validation of affiliates to a Health Care company. This company uses HL7 internally. Also this company does not let you to contact them directly, you must use a carrier (another company who gets your message and, after validating it sends the data in HL7 format to the Health Care company). Some of this carriers asks for a plain (and proprietary) text file format to communicate with them, sometimes they expose an HL7 interface (Kudos from me to them).

Luckily for me in Argentina a long time ago there was an agreement (I don’t remember how I got this info, but it’s true) among the Carriers and the Health Care Companies to standardize the HL7 format for several operations (among others, the operations I needed to do).

HL7 Note: In reference to HL7, the protocol aims to create new customized messages types when those provided by the norm does not fit the business need. These messages are called Z messages. The Z messages can contain Z segments and Z groups, and all are locally defined by norm, so you can end up with a colliding set of HL7 Z elements (the same name of Z message/segment/group but different internal definition). In a nutshell: a nightmare.

Both HAPI and NHAPI are open source libraries and I choose NHAPI for the samples because I already have some code made on it.

Let’s define a new Z Segment:

Show the code

Let’s define a new Z Message:

Show the code

using System;
using NHapi.Base;
using NHapi.Base.Log;
using NHapi.Base.Model;
using NHapi.Base.Parser;
using NHapi.Model.V24.Group;
using NHapi.Model.V24.Segment;
using ValidationProvider.HL7.Segment;

namespace NHapi.Model.V24.Message
{
    [Serializable]
    public class ZLA_Z22 : AbstractMessage
    {
        private string _n1;
        private string _n2;
        private string _n3;
        private string _n4;

        /// Creates a new ZLA_Z22 Group with custom IModelClassFactory.
        ///
        public ZLA_Z22(IModelClassFactory factory)
            : base(factory)
        {
            Init(factory);
        }

        ///
        /// Creates a new ZLA_Z22 Group with DefaultModelClassFactory.
        ///
        public ZLA_Z22()
            : base(new DefaultModelClassFactory())
        {
            Init(new DefaultModelClassFactory());
        }

        ///
        /// initalize method for ZLA_Z22.  This does the segment setup for the message.
        ///
        private void Init(IModelClassFactory factory)
        {
            try
            {
                add(typeof(MSH), true, false);
                _n1 = add(typeof(ZLA_Z22_Authorization), false, false);
                add(typeof(ZXX), false, false);
                _n2 = add(typeof(ZLA_Z22_Data), true, false);
                add(typeof(PID), false, false);
                _n3 = add(typeof(ZLA_Z22_Insurance), false, true);
                add(typeof(DG1), false, true);
                _n4 = add(typeof(ZLA_Z22_ProcedureZ), true, true);
                add(typeof(PV1), false, false);
                add(typeof(NTE), false, true);
            }
            catch (HL7Exception e)
            {
                HapiLogFactory.GetHapiLog(GetType()).Error("Unexpected error creating " + GetType().Name + " - this is probably a bug in the source code generator.", e);
            }
        }

        #region Segments
        public MSH MSH
        {
            get
            {
                MSH ret;
                try
                {
                    ret = (MSH)GetStructure("MSH");
                }
                catch (HL7Exception e)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error("Unexpected error accessing data - this is probably a bug in the source code generator.", e);
                    throw new Exception("An unexpected error ocurred", e);
                }
                return ret;
            }
        }

        public ZLA_Z22_Authorization Authorization
        {
            get
            {
                ZLA_Z22_Authorization ret;
                try
                {
                    ret = (ZLA_Z22_Authorization)GetStructure(_n1);
                }
                catch (HL7Exception e)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error("Unexpected error accessing data - this is probably a bug in the source code generator.", e);
                    throw new Exception("An unexpected error ocurred", e);
                }
                return ret;
            }
        }
        public ZXX ZXX
        {
            get
            {
                ZXX ret;
                try
                {
                    ret = (ZXX)GetStructure("ZXX");
                }
                catch (HL7Exception e)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error("Unexpected error accessing data - this is probably a bug in the source code generator.", e);
                    throw new Exception("An unexpected error ocurred", e);
                }
                return ret;
            }
        }
        #region ZLA_Z22_Data
        ///
        /// Returns  first repetition of ZLA_Z22_Data (Notes and Comments) - creates it if necessary
        ///
        public ZLA_Z22_Data GetZLA_Z22_Data()
        {
            ZLA_Z22_Data ret = null;
            try
            {
                ret = (ZLA_Z22_Data)GetStructure(_n2);
            }
            catch (HL7Exception e)
            {
                HapiLogFactory.GetHapiLog(GetType()).Error("Unexpected error accessing data - this is probably a bug in the source code generator.", e);
                throw new System.Exception("An unexpected error ocurred", e);
            }
            return ret;
        }

        ///
        ///Returns a specific repetition of ZLA_Z22_Data
        /// * (Notes and Comments) - creates it if necessary
        /// throws HL7Exception if the repetition requested is more than one
        ///     greater than the number of existing repetitions.
        ///
        public ZLA_Z22_Data GetZLA_Z22_Data(int rep)
        {
            return (ZLA_Z22_Data)GetStructure(_n2, rep);
        }

        /**
         * Returns the number of existing repetitions of ZLA_Z22_Data
         */
        public int ZLA_Z22_DataRepetitionsUsed
        {
            get
            {
                int reps = -1;
                try
                {
                    reps = GetAll(_n2).Length;
                }
                catch (HL7Exception e)
                {
                    const string message = "Unexpected error accessing data - this is probably a bug in the source code generator.";
                    HapiLogFactory.GetHapiLog(GetType()).Error(message, e);
                    throw new System.Exception(message);
                }
                return reps;
            }
        }

        #endregion
        public PID PID
        {
            get
            {
                PID ret;
                try
                {
                    ret = (PID)GetStructure("PID");
                }
                catch (HL7Exception e)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error("Unexpected error accessing data - this is probably a bug in the source code generator.", e);
                    throw new Exception("An unexpected error ocurred", e);
                }
                return ret;
            }
        }
        #region ZLA_Z22_Insurance
        ///
        /// Returns  first repetition of ZLA_Z22_Insurance (Notes and Comments) - creates it if necessary
        ///
        public ZLA_Z22_Insurance GetZLA_Z22_Insurance()
        {
            ZLA_Z22_Insurance ret = null;
            try
            {
                ret = (ZLA_Z22_Insurance)GetStructure(_n3);
            }
            catch (HL7Exception e)
            {
                HapiLogFactory.GetHapiLog(GetType()).Error("Unexpected error accessing data - this is probably a bug in the source code generator.", e);
                throw new System.Exception("An unexpected error ocurred", e);
            }
            return ret;
        }

        ///
        ///Returns a specific repetition of ZLA_Z22_Insurance
        /// * (Notes and Comments) - creates it if necessary
        /// throws HL7Exception if the repetition requested is more than one
        ///     greater than the number of existing repetitions.
        ///
        public ZLA_Z22_Insurance GetZLA_Z22_Insurance(int rep)
        {
            return (ZLA_Z22_Insurance)GetStructure(_n3, rep);
        }

        /**
         * Returns the number of existing repetitions of ZLA_Z22_Insurance
         */
        public int ZLA_Z22_InsuranceRepetitionsUsed
        {
            get
            {
                int reps = -1;
                try
                {
                    reps = GetAll(_n3).Length;
                }
                catch (HL7Exception e)
                {
                    const string message = "Unexpected error accessing data - this is probably a bug in the source code generator.";
                    HapiLogFactory.GetHapiLog(GetType()).Error(message, e);
                    throw new Exception(message);
                }
                return reps;
            }
        }
        #endregion
        #region ZIN
        ///
        /// Returns  first repetition of ZIN (Notes and Comments) - creates it if necessary
        ///
        public ZIN GetZIN()
        {
            ZIN ret = null;
            try
            {
                ret = (ZIN)GetStructure("ZIN");
            }
            catch (HL7Exception e)
            {
                HapiLogFactory.GetHapiLog(GetType()).Error("Unexpected error accessing data - this is probably a bug in the source code generator.", e);
                throw new System.Exception("An unexpected error ocurred", e);
            }
            return ret;
        }

        ///
        ///Returns a specific repetition of ZIN
        /// * (Notes and Comments) - creates it if necessary
        /// throws HL7Exception if the repetition requested is more than one
        ///     greater than the number of existing repetitions.
        ///
        public ZIN GetZIN(int rep)
        {
            return (ZIN)GetStructure("ZIN", rep);
        }

        /**
         * Returns the number of existing repetitions of ZIN
         */
        public int ZINRepetitionsUsed
        {
            get
            {
                int reps = -1;
                try
                {
                    reps = GetAll("ZIN").Length;
                }
                catch (HL7Exception e)
                {
                    const string message = "Unexpected error accessing data - this is probably a bug in the source code generator.";
                    HapiLogFactory.GetHapiLog(GetType()).Error(message, e);
                    throw new System.Exception(message);
                }
                return reps;
            }
        }

        #endregion
        #region DG1
        ///
        /// Returns  first repetition of DG1 (Notes and Comments) - creates it if necessary
        ///
        public DG1 GetDG1()
        {
            DG1 ret = null;
            try
            {
                ret = (DG1)GetStructure("DG1");
            }
            catch (HL7Exception e)
            {
                HapiLogFactory.GetHapiLog(GetType()).Error("Unexpected error accessing data - this is probably a bug in the source code generator.", e);
                throw new System.Exception("An unexpected error ocurred", e);
            }
            return ret;
        }

        ///
        ///Returns a specific repetition of DG1
        /// * (Notes and Comments) - creates it if necessary
        /// throws HL7Exception if the repetition requested is more than one
        ///     greater than the number of existing repetitions.
        ///
        public DG1 GetDG1(int rep)
        {
            return (DG1)GetStructure("DG1", rep);
        }

        /**
         * Returns the number of existing repetitions of DG1
         */
        public int DG1RepetitionsUsed
        {
            get
            {
                int reps = -1;
                try
                {
                    reps = GetAll("DG1").Length;
                }
                catch (HL7Exception e)
                {
                    const string message = "Unexpected error accessing data - this is probably a bug in the source code generator.";
                    HapiLogFactory.GetHapiLog(GetType()).Error(message, e);
                    throw new System.Exception(message);
                }
                return reps;
            }
        }

        #endregion
        #region ZLA_Z22_ProcedureZ
        ///
        /// Returns  first repetition of ZLA_Z22_ProcedureZ (Notes and Comments) - creates it if necessary
        ///
        public ZLA_Z22_ProcedureZ GetZLA_Z22_ProcedureZ()
        {
            ZLA_Z22_ProcedureZ ret = null;
            try
            {
                ret = (ZLA_Z22_ProcedureZ)GetStructure(_n4);
            }
            catch (HL7Exception e)
            {
                HapiLogFactory.GetHapiLog(GetType()).Error("Unexpected error accessing data - this is probably a bug in the source code generator.", e);
                throw new System.Exception("An unexpected error ocurred", e);
            }
            return ret;
        }

        ///
        ///Returns a specific repetition of ZLA_Z22_ProcedureZ
        /// * (Notes and Comments) - creates it if necessary
        /// throws HL7Exception if the repetition requested is more than one
        ///     greater than the number of existing repetitions.
        ///
        public ZLA_Z22_ProcedureZ GetZLA_Z22_ProcedureZ(int rep)
        {
            return (ZLA_Z22_ProcedureZ)GetStructure(_n4, rep);
        }

        /**
         * Returns the number of existing repetitions of ZLA_Z22_ProcedureZ
         */
        public int ZLA_Z22_ProcedureZRepetitionsUsed
        {
            get
            {
                int reps = -1;
                try
                {
                    reps = GetAll(_n4).Length;
                }
                catch (HL7Exception e)
                {
                    string message = "Unexpected error accessing data - this is probably a bug in the source code generator.";
                    HapiLogFactory.GetHapiLog(GetType()).Error(message, e);
                    throw new System.Exception(message);
                }
                return reps;
            }
        }
        #endregion
        public PV1 PV1
        {
            get
            {
                PV1 ret;
                try
                {
                    ret = (PV1)GetStructure("PV1");
                }
                catch (HL7Exception e)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error("Unexpected error accessing data - this is probably a bug in the source code generator.", e);
                    throw new Exception("An unexpected error ocurred", e);
                }
                return ret;
            }
        }
        #region NTE
        ///
        /// Returns  first repetition of NTE (Notes and Comments) - creates it if necessary
        ///
        public NTE GetNTE()
        {
            NTE ret = null;
            try
            {
                ret = (NTE)GetStructure("NTE");
            }
            catch (HL7Exception e)
            {
                HapiLogFactory.GetHapiLog(GetType()).Error("Unexpected error accessing data - this is probably a bug in the source code generator.", e);
                throw new System.Exception("An unexpected error ocurred", e);
            }
            return ret;
        }

        ///
        ///Returns a specific repetition of NTE
        /// * (Notes and Comments) - creates it if necessary
        /// throws HL7Exception if the repetition requested is more than one
        ///     greater than the number of existing repetitions.
        ///
        public NTE GetNTE(int rep)
        {
            return (NTE)GetStructure("NTE", rep);
        }

        /**
         * Returns the number of existing repetitions of NTE
         */
        public int NTERepetitionsUsed
        {
            get
            {
                int reps = -1;
                try
                {
                    reps = GetAll("NTE").Length;
                }
                catch (HL7Exception e)
                {
                    const string message = "Unexpected error accessing data - this is probably a bug in the source code generator.";
                    HapiLogFactory.GetHapiLog(GetType()).Error(message, e);
                    throw new System.Exception(message);
                }
                return reps;
            }
        }

        #endregion

        #endregion
    }
}

Note: This is not the original post. I had to modify it to avoid futher problems with a previous employer. Feel free to contact me for any HL7 questions you may have.

using System;
using NHapi.Base;
using NHapi.Base.Parser;
using NHapi.Base.Model;
using NHapi.Model.V24.Datatype;
using NHapi.Base.Log;

namespace ValidationProvider.HL7.Segment
{
    ///
    /// Represents a ZXX Segment. This is a locally defined segment
    ///
    [Serializable]
    public sealed class ZXX : AbstractSegment
    {
        public ZXX(IGroup parent, IModelClassFactory factory): base(parent, factory)
        {
            IMessage message = Message;
            try
            {
                add(typeof(EI), true, 0, 1, new object[] { message }, "NroControlDelPrestador");
                add(typeof(EI), false,1, 4, new object[] { message }, "NroControlDelFinanciador");
                add(typeof(CE), false, 1, 180, new object[] { message }, "EstadoDeLaAutorizacion");
                add(typeof(EI), false, 1, 180, new object[] { message }, "NumeroDePreAutorizacion");
                add(typeof(TS), false, 1, 180, new object[] { message }, "FechaDeEmisionDePreAutorizacion");
                add(typeof(CPMO), false, 1, 180, new object[] { message }, "ValorDelArancelDelCopago");
            }
            catch (HL7Exception he)
            {
                HapiLogFactory.GetHapiLog(GetType()).Error("Can't instantiate " + GetType().Name, he);
            }

        }

        public EI NroControlPrestador
        {
            get
            {
                EI ret;
                try
                {
                    IType t = GetField(1,0);
                    ret = (EI)t;
                }
                catch (HL7Exception he)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error(
                        "Unexpected problem obtaining field value.  This is a bug.", he);
                    throw new Exception("An unexpected error ocurred", he);
                }
                catch (Exception ex)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error(
                        "Unexpected problem obtaining field value.  This is a bug.", ex);
                    throw new Exception("An unexpected error ocurred", ex);
                }
                return ret;

            }
        }

        public EI NroControlFinanciador
        {
            get
            {
                EI ret;
                try
                {
                    IType t = GetField(2, 0);
                    ret = (EI)t;
                }
                catch (HL7Exception he)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error(
                        "Unexpected problem obtaining field value.  This is a bug.", he);
                    throw new Exception("An unexpected error ocurred", he);
                }
                catch (Exception ex)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error(
                        "Unexpected problem obtaining field value.  This is a bug.", ex);
                    throw new Exception("An unexpected error ocurred", ex);
                }
                return ret;

            }
        }

        public CE EstadoAutorizacion
        {
            get
            {
                CE ret;
                try
                {
                    IType t = GetField(3, 0);
                    ret = (CE)t;
                }
                catch (HL7Exception he)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error(
                        "Unexpected problem obtaining field value.  This is a bug.", he);
                    throw new Exception("An unexpected error ocurred", he);
                }
                catch (Exception ex)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error(
                        "Unexpected problem obtaining field value.  This is a bug.", ex);
                    throw new Exception("An unexpected error ocurred", ex);
                }
                return ret;

            }
        }

        public EI NumeroPreAutorizacion
        {
            get
            {
                EI ret;
                try
                {
                    IType t = GetField(4, 0);
                    ret = (EI)t;
                }
                catch (HL7Exception he)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error(
                        "Unexpected problem obtaining field value.  This is a bug.", he);
                    throw new Exception("An unexpected error ocurred", he);
                }
                catch (Exception ex)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error(
                        "Unexpected problem obtaining field value.  This is a bug.", ex);
                    throw new Exception("An unexpected error ocurred", ex);
                }
                return ret;

            }
        }

        public TS FechaEmisionPreAutorizacion
        {
            get
            {
                TS ret;
                try
                {
                    IType t = GetField(5, 0);
                    ret = (TS)t;
                }
                catch (HL7Exception he)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error(
                        "Unexpected problem obtaining field value.  This is a bug.", he);
                    throw new Exception("An unexpected error ocurred", he);
                }
                catch (Exception ex)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error(
                        "Unexpected problem obtaining field value.  This is a bug.", ex);
                    throw new Exception("An unexpected error ocurred", ex);
                }
                return ret;

            }
        }
        public CPMO ValorArancelCopago
        {
            get
            {
                CPMO ret;
                try
                {
                    IType t = GetField(6, 0);
                    ret = (CPMO)t;
                }
                catch (HL7Exception he)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error(
                        "Unexpected problem obtaining field value.  This is a bug.", he);
                    throw new Exception("An unexpected error ocurred", he);
                }
                catch (Exception ex)
                {
                    HapiLogFactory.GetHapiLog(GetType()).Error(
                        "Unexpected problem obtaining field value.  This is a bug.", ex);
                    throw new Exception("An unexpected error ocurred", ex);
                }
                return ret;

            }
        }

    }
}

Working with HL7 Part 1

gbrusella — Mon, 14 Sep 2009 19:08:57 +0000

What is HL7

HL7 is a standar for health’s clinical and administrative data. One of objective of this standard is to develop a coherent, extendible standard that permit structured, encoded health care information of the type required to support patient care, to be exchanged between computer applications while preserving meaning.

How a HL7 Message looks like

MSH|^~\&|GHH LAB|ELAB-3|GHH OE|BLDG4|200202150930||ORU^R01|CNTRL-3456|P|2.4
PID|||555-44-4444||EVERYWOMAN^EVE^E^^^^L|JONES|19620320|F|||153 FERNWOOD DR.^^STATESVILLE^OH^35292||(206)3345232|(206)752-121||||AC555444444||67-A4335^OH^20030520
OBR|1|845439^GHH OE|1045813^GHH LAB|15545^GLUCOSE|||200202150730|||||||||555-55-5555^PRIMARY^PATRICIA P^^^^MD^^|||||||||F||||||444-44-4444^HIPPOCRATES^HOWARD H^^^^MD
OBX|1|SN|1554-5^GLUCOSE^POST 12H CFST:MCNC:PT:SER/PLAS:QN||^182|mg/dl|70_105|H|||F

Yes… Looks strange at first sight… but believe me, it is perfectly logic.

Dissecting the message

An HL7 message consists of the following data elements.

Message type

An HL7 message type is a unique identifier for the business purpose of a message. Every message must contain a message type id as way to announce the purpose of the message. For example, ADT is a unique message ID to Patient Administration.

However, it is rather not a unique classification on the structure of a message. One message type can have more than one message structure.

The message type is advertised in the message header segment

Message event

The message event, sometimes called a trigger, is a unique identifier to the context in which message is generated. The message event consists of an upper case letter and two digits. For example, A01 is for admission/visit notification and A61 is for changing consulting doctor. Both A01 and A61 are used with ADT messages

Event type is advertised in the message header segment.

Message structure

The message structure is a data structure used to express an association of a message type with an event for a class of messages. Each message structure also contains a unique ID.

It structurally consists of a well-defined list of HL7 segments. Segments can be optional, and can repeat. There is no limit on how many times a segment can repeat.

Segments can be aggregated together to form a segment group, which can repeat as well. In the standard specification, segment group is indicated by {} or [], where {} signifies repetition and [] signifies optionality.

Relative position of segments in a message structure and segment groups is well defined. At the message structure level, segment is the atomic data type.

Message structures are defined by both message type and events. One message type can associate with more than one event, but one event can only associate with exactly one message type. Furthermore, some events with a given message type associate with the same message structure. For example message type ADT with both event A01 and event A04 uses message structure ADT_A01

Message structure of ADT_A61

ADT^A61^ADT_A61	ADT Message
MSH	Message header
EVN	Event type
[ PD1 ]	Additional demographics
[ {ROL} ]	Roll
[ PV2 ]	Patient visit–additional information

Segments

Segment is a well-defined list attributes, each of an HL7 data type. All segments start with three upper case letter segment IDs. Segment attributes can be optional and can repeat. The maximum number of how many times an attribute can repeat is specified. Various tables define the validity of certain attribute value.

Note: The relative position of segment attribute is significant in how it is defined.

Every segment ends with a segment terminator, either the ASCII carriage return or x0D.

HL7 calls the segment attribute Field. The standard designates a delimiter, whose value is a defined by the user on per message instances basis, to separate fields.

When the fields repeat, the standard designates a user-defined delimiter, whose value is defined on per message instance basis, to separate repeating fields. Delimiters that separate repeating instances of a field are also defined by use, and call repetition

Separator	Character
Segment	\x0D
Field Repeat	~
Null Value	“”
1st Level Field	\|
2nd Level Field	^
3rd Level Field	&
User Defined String 1	\

MSH segment specification

	Name	Data Type	Required	Length	Repeats
1	field separator	String	Yes	0…1	1..1
2	encoding characters	String	Yes	0…4	1..1
3	sending application	HD	No	0…180	..
4	sending facility	HD	No	0…180	..
5	receiving application	HD	No	0…180	..
6	receiving facility	HD	No	0…180	..
7	Date Time Of Message	TS	Yes	0…26	..
8	Security	String	No	0…40	..
9	message type	CM_MT	Yes	0…15	1..1
10	Message Control ID	String	Yes	0…36	1..1
11	Processing ID	PT	Yes	0…3	1..1
12	Version ID	VID	Yes	0…60	1..1
13	sequence number	4 Byte Long	No	0…15	..
14	continuation pointer	String	No	0…180	..
15	AcceptAcknowledgementType	String	No	0…2	..
16	ApplicationAcknowledgementType	String	No	0…2	..
17	country code	String	No	0…3	..
18	character set	String	No	0…7	0..No Max
19	PrincipalLanguageOfMessage	CE	No	0…250	..
20	AlternateCharacterSetHandlingScheme	String	No	0…20	..
21	ConformanceStatementId	String	No	0…10	0..No Max

Note: In the previous table, “Len” stands for maximum length in number of characters; “DT” stands for data type; “OPT” stands for optionality; “Element Name” stands for brief descriptive name of the field.

The structures of many segments are statically defined and can be shared in many message structures. There are also some segments that share the same segment ID but have a different structure — different attribute in name and data type. QPD, QED, RCP, QAK belong to this category of segments

Data types

HL7 defines a long list of data types. Some are as defined as a primitive type, while others are defined as a complex type. A complex data type consists of more than one attribute of the primitive type. HL7 calls the attributes of a complex data type a component

For example, the following HD data type uses three components, namespace ID, universal ID, and universal ID type.

^^

The standard designates a delimiter, whose value is defined by the user on per message instances basis, to separate components.

Other complex data type can further define a component of a given data type. HL7 calls the attribute of this complex data type subcomponent. The complex data type must have all attributes be of primitive type.

The standard also designates a delimiter to separate subcomponents whose value is defined by the user on per message instances basis.

The component delimiter of the data type that defines a component is then demoted to subcomponent delimiter.

HL7 also designates an escape character for escapting characters that are identical to various delimiters. These are defined by the user on per message instance basis.

Most data types are well are statically specified as distinct data structures in the standard. A few data types, notably the CM and * data type, exhibit dynamic behavior, and warrant special attention.

Custom made data types

CM is also called a Composite data type. This data type is a custom construction using previously defined data types for each unique situation, in a different segment, or at different field of the same segment. There are number of data structures associated with the CM data type.

The data structures for the CM types, which can differ widely from one another, are solidified at time when segments they belong to are defined. The CM data type is known at design time.

In earlier versions of the HL7 standard, CM is meant to be custom-made data type, data type defined on local site of deployment. For this reason, CM data type represents endless number of structures with different combination and permutation of readily defined data types.

Version 2.4 of HL7 only has finite number of data structures that is labeled with CM data type.

Polymorphic data type

This is the data type that is marked with * symbol or with “varies” data type label, instead of the usual two or three capital letters.

This data type exhibits a common behavior that it can be any one of the already defined data type and the data type is declare in some other place. For example, OBX-2 declares the data type of OBX-5, which is actual data carrier of this polymorphic data type. For ease of discussion, lets call the field that announce the data type of polymorphic data type data Data Type Announcer, and call the field that contains the actual data of the polymorphic data type Data Carrier.

The data type announcer and data carrier can coexist in the same segment; they can also exist on different segments. For example, OBX segment has OBX-2 field being the data type announcer and OBX-5 field being the data carrier. RDF segment contains a field of RCD data type, of which each instance of the RCD field acts as a data announcer for data carrier in the RDT segment. The relationship of the RDF and RDT segment is in analogues to relationship database’s table description meta-data and rows of actual data.

In the case of both data type announcer and data carrier residing in the same segment, the relative position of the announcer field and the data carrier field can also vary. Data type announcer can precede data carrier, or the other way around.

There is no fixed number of fields that sets data type announcer and data carrier apart. Their relationship is shown in the following diagram.

Delimiter and enhaced data model

The delimiters for segment, field, component, and subcomponent are all user-defined Delimiters are announced in the message header for each individual message.

A segment delimiter is defined as an ASCII carriage return or x0A. When data containing the characters identical to these delimiters, an escape sequence is used to mark the character.

Component delimiters can be demoted to subcomponent delimiters when a data type is used on anther data type’s components. The use of repetition delimiters in most data elements is contextual depending the nature of its data elements, with certain excpetions.

The repetition delimiter is used between repeating instances of data type element segment fields. The common character used is “~”. Components of data type element are generally not expected to repeat, except for MA, NA, and QIP data types.